queue-typed 1.47.5 → 1.47.7

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

@@ -27,21 +27,23 @@ exports.RedBlackTreeNode = RedBlackTreeNode;
  */
 class RedBlackTree extends bst_1.BST {
     /**
-     * The constructor function initializes a Red-Black Tree with an optional set of options.
-     * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
-     * passed to the constructor. It is used to configure the RBTree object with specific options.
+     * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
+     * initializes the tree with optional elements and options.
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * objects. It represents the initial elements that will be added to the RBTree during its
+     * construction. If this parameter is provided, the `addMany` method is called to add all the
+     * elements to the
+     * @param [options] - The `options` parameter is an optional object that allows you to customize the
+     * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
+     * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(options) {
-        super(options);
+    constructor(elements, options) {
+        super([], options);
         this.Sentinel = new RedBlackTreeNode(NaN);
         this._size = 0;
-        if (options) {
-            this.options = Object.assign({ iterationType: types_1.IterationType.ITERATIVE, comparator: (a, b) => a - b }, options);
-        }
-        else {
-            this.options = { iterationType: types_1.IterationType.ITERATIVE, comparator: (a, b) => a - b };
-        }
         this._root = this.Sentinel;
+        if (elements)
+            super.addMany(elements);
     }
     get root() {
         return this._root;
@@ -49,40 +51,60 @@ class RedBlackTree extends bst_1.BST {
     get size() {
         return this._size;
     }
+    /**
+     * The function creates a new Red-Black Tree node with the specified key, value, and color.
+     * @param {BTNKey} key - The key parameter is the key value associated with the node. It is used to
+     * identify and compare nodes in the Red-Black Tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the node. It is of type `V`, which is a generic type that can be replaced with any
+     * specific type when using the `createNode` method.
+     * @param {RBTNColor} color - The "color" parameter is used to specify the color of the node in a
+     * Red-Black Tree. It can be either "RED" or "BLACK". By default, the color is set to "BLACK".
+     * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
+     * value, and color.
+     */
     createNode(key, value, color = types_1.RBTNColor.BLACK) {
         return new RedBlackTreeNode(key, value, color);
     }
+    /**
+     * The function creates a Red-Black Tree with the specified options and returns it.
+     * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
+     * passed to the `createTree` function. It is used to customize the behavior of the `RedBlackTree`
+     * class.
+     * @returns a new instance of a RedBlackTree object.
+     */
     createTree(options) {
-        return new RedBlackTree(Object.assign(Object.assign({}, this.options), options));
+        return new RedBlackTree([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
      */
     /**
-     * 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 Red-Black Tree data structure.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The `value` parameter is an optional value that can be associated with the
-     * key in the node being added to the Red-Black Tree.
-     * @returns The method returns either a node (`N`) or `undefined`.
+     * The function adds a node to a Red-Black Tree data structure.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
+     * @returns The method `add` returns either an instance of `N` (the node that was added) or
+     * `undefined`.
      */
-    add(keyOrNode, value) {
+    add(keyOrNodeOrEntry) {
         let node;
-        if (this.isNodeKey(keyOrNode)) {
-            node = this.createNode(keyOrNode, value, types_1.RBTNColor.RED);
+        if (this.isNodeKey(keyOrNodeOrEntry)) {
+            node = this.createNode(keyOrNodeOrEntry, undefined, types_1.RBTNColor.RED);
         }
-        else if (keyOrNode instanceof RedBlackTreeNode) {
-            node = keyOrNode;
+        else if (keyOrNodeOrEntry instanceof RedBlackTreeNode) {
+            node = keyOrNodeOrEntry;
         }
-        else if (keyOrNode === null) {
+        else if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined) {
             return;
         }
-        else if (keyOrNode === undefined) {
-            return;
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
+            if (key === undefined || key === null) {
+                return;
+            }
+            else {
+                node = this.createNode(key, value, types_1.RBTNColor.RED);
+            }
         }
         else {
             return;
@@ -101,6 +123,9 @@ class RedBlackTree extends bst_1.BST {
                     x = x === null || x === void 0 ? void 0 : x.right;
                 }
                 else {
+                    if (node !== x) {
+                        this._replaceNode(x, node);
+                    }
                     return;
                 }
             }
@@ -204,6 +229,10 @@ class RedBlackTree extends bst_1.BST {
         // TODO
         return ans;
     }
+    /**
+     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Space Complexity: O(1)
+     */
     isRealNode(node) {
         return node !== this.Sentinel && node !== undefined;
     }
@@ -232,11 +261,11 @@ class RedBlackTree extends bst_1.BST {
      * `getNodes` method, which is called within the `getNode` method.
      * @returns a value of type `N`, `null`, or `undefined`.
      */
-    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
         var _a;
         if (identifier instanceof binary_tree_1.BinaryTreeNode)
             callback = (node => node);
-        beginRoot = this.ensureNotKey(beginRoot);
+        beginRoot = this.ensureNode(beginRoot);
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
@@ -287,6 +316,10 @@ class RedBlackTree extends bst_1.BST {
         }
         return y;
     }
+    /**
+     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Space Complexity: O(1)
+     */
     clear() {
         this._root = this.Sentinel;
         this._size = 0;
@@ -520,5 +553,18 @@ class RedBlackTree extends bst_1.BST {
         }
         this.root.color = types_1.RBTNColor.BLACK;
     }
+    /**
+     * The function replaces an old node with a new node while preserving the color of the old node.
+     * @param {N} oldNode - The `oldNode` parameter represents the node that needs to be replaced in a
+     * data structure. It is of type `N`, which is the type of the nodes in the data structure.
+     * @param {N} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
+     * data structure.
+     * @returns The method is returning the result of calling the `_replaceNode` method from the
+     * superclass, passing in the `oldNode` and `newNode` as arguments.
+     */
+    _replaceNode(oldNode, newNode) {
+        newNode.color = oldNode.color;
+        return super._replaceNode(oldNode, newNode);
+    }
 }
 exports.RedBlackTree = RedBlackTree;

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BTNKey, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
+import type { BSTNodeKeyOrNode, BTNKey, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
 import { BiTreeDeleteResult, BTNCallback, IterationType, TreeMultimapNested } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
@@ -27,14 +27,7 @@ export declare class TreeMultimapNode<V = any, N extends TreeMultimapNode<V, N>
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNode<V, TreeMultimapNodeNested<V>>, TREE extends TreeMultimap<V, N, TREE> = TreeMultimap<V, N, TreeMultimapNested<V, N>>> extends AVLTree<V, N, TREE> implements IBinaryTree<V, N, TREE> {
-    options: TreeMultimapOptions;
-    /**
-     * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
-     * merge duplicated values.
-     * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
-     * TreeMultimap.
-     */
-    constructor(options?: TreeMultimapOptions);
+    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<TreeMultimapOptions>);
     private _count;
     get count(): number;
     /**
@@ -56,38 +49,33 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * 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 `add` function adds a new node to the tree multimap, updating the count if the key already
-     * exists, and balances the tree if necessary.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the tree. It is an optional parameter, so it can be omitted if not needed.
+     * The `add` function overrides the base class `add` function to add a new node to the tree multimap
+     * and update the count.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the multimap. If not provided, the default value is 1.
-     * @returns a node (`N`) or `undefined`.
+     * times the key or node or entry should be added to the multimap. If not provided, the default value
+     * is 1.
+     * @returns either a node (`N`) or `undefined`.
      */
-    add(keyOrNode: BTNKey | N | null | undefined, value?: V, count?: number): N | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>, count?: number): N | undefined;
     /**
-     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(k 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.
      */
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
+     * Time Complexity: O(k 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 `addMany` takes an array of keys or nodes and adds them to the TreeMultimap,
-     * returning an array of the inserted nodes.
-     * @param {(BTNKey | N | undefined)[]} keysOrNodes - An array of keys or nodes. Each element can be
-     * of type BTNKey, N, or undefined.
-     * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond to the
-     * keys or nodes being added. It is used to associate data with each key or node being added to the
-     * TreeMultimap. If provided, the length of the `data` array should be the same as the length of the
-     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+     * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
+     * structure.
+     * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
+     * either keys, nodes, or entries.
+     * @returns The method is returning an array of type `N | undefined`.
      */
-    addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: V[]): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<V, N>>): (N | undefined)[];
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
+     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
      */
     /**
      * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
@@ -100,10 +88,10 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * values:
      * @returns a boolean value.
      */
-    perfectlyBalance(iterationType?: IterationType | undefined): boolean;
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
+     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
@@ -126,8 +114,8 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      */
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BiTreeDeleteResult<N>[];
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete 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.
+     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
+     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
      */
     /**
      * The clear() function clears the contents of a data structure and sets the count to zero.
@@ -148,9 +136,9 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
      * added, or `undefined` if no node was added.
      */
-    protected _addTo(newNode: N | undefined, parent: BTNKey | N | undefined): N | undefined;
+    protected _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<N>): N | undefined;
     /**
-     * The `_swap` function swaps the key, value, count, and height properties between two nodes.
+     * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
      * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
      * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
      * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
@@ -158,5 +146,6 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    protected _swap(srcNode: BTNKey | N | undefined, destNode: BTNKey | N | undefined): N | undefined;
+    protected _swapProperties(srcNode: BSTNodeKeyOrNode<N>, destNode: BSTNodeKeyOrNode<N>): N | undefined;
+    protected _replaceNode(oldNode: N, newNode: N): N;
 }

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

@@ -24,24 +24,17 @@ exports.TreeMultimapNode = TreeMultimapNode;
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 class TreeMultimap extends avl_tree_1.AVLTree {
-    /**
-     * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
-     * merge duplicated values.
-     * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
-     * TreeMultimap.
-     */
-    constructor(options = { iterationType: types_1.IterationType.ITERATIVE }) {
-        super(options);
+    constructor(elements, options) {
+        super([], options);
         this._count = 0;
-        if (options) {
-            this.options = Object.assign({ iterationType: types_1.IterationType.ITERATIVE, comparator: (a, b) => a - b }, options);
-        }
-        else {
-            this.options = { iterationType: types_1.IterationType.ITERATIVE, comparator: (a, b) => a - b };
-        }
+        if (elements)
+            this.addMany(elements);
     }
+    // TODO the _count is not accurate after nodes count modified
     get count() {
-        return this._count;
+        let sum = 0;
+        this.subTreeTraverse(node => sum += node.count);
+        return sum;
     }
     /**
      * The function creates a new BSTNode with the given key, value, and count.
@@ -56,7 +49,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return new TreeMultimapNode(key, value, count);
     }
     createTree(options) {
-        return new TreeMultimap(Object.assign(Object.assign({}, this.options), options));
+        return new TreeMultimap([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
     /**
      * 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.
@@ -66,131 +59,64 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * 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 `add` function adds a new node to the tree multimap, updating the count if the key already
-     * exists, and balances the tree if necessary.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the tree. It is an optional parameter, so it can be omitted if not needed.
+     * The `add` function overrides the base class `add` function to add a new node to the tree multimap
+     * and update the count.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be added to the multimap. If not provided, the default value is 1.
-     * @returns a node (`N`) or `undefined`.
+     * times the key or node or entry should be added to the multimap. If not provided, the default value
+     * is 1.
+     * @returns either a node (`N`) or `undefined`.
      */
-    add(keyOrNode, value, count = 1) {
-        if (keyOrNode === null)
-            return undefined;
-        let inserted = undefined, newNode;
-        if (keyOrNode instanceof TreeMultimapNode) {
-            newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
+    add(keyOrNodeOrEntry, count = 1) {
+        let newNode;
+        if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
+            return;
         }
-        else if (keyOrNode === undefined) {
-            newNode = undefined;
+        else if (keyOrNodeOrEntry instanceof TreeMultimapNode) {
+            newNode = keyOrNodeOrEntry;
         }
-        else {
-            newNode = this.createNode(keyOrNode, value, count);
+        else if (this.isNodeKey(keyOrNodeOrEntry)) {
+            newNode = this.createNode(keyOrNodeOrEntry, undefined, count);
         }
-        if (!this.root) {
-            this._setRoot(newNode);
-            this._size = this.size + 1;
-            if (newNode)
-                this._count += newNode.count;
-            inserted = this.root;
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
+            if (key === undefined || key === null) {
+                return;
+            }
+            else {
+                newNode = this.createNode(key, value, count);
+            }
         }
         else {
-            let cur = this.root;
-            let traversing = true;
-            while (traversing) {
-                if (cur) {
-                    if (newNode) {
-                        if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
-                            cur.value = newNode.value;
-                            cur.count += newNode.count;
-                            this._count += newNode.count;
-                            traversing = false;
-                            inserted = cur;
-                        }
-                        else if (this._compare(cur.key, newNode.key) === types_1.CP.gt) {
-                            // Traverse left of the node
-                            if (cur.left === undefined) {
-                                //Add to the left of the current node
-                                cur.left = newNode;
-                                this._size = this.size + 1;
-                                this._count += newNode.count;
-                                traversing = false;
-                                inserted = cur.left;
-                            }
-                            else {
-                                //Traverse the left of the current node
-                                if (cur.left)
-                                    cur = cur.left;
-                            }
-                        }
-                        else if (this._compare(cur.key, newNode.key) === types_1.CP.lt) {
-                            // Traverse right of the node
-                            if (cur.right === undefined) {
-                                //Add to the right of the current node
-                                cur.right = newNode;
-                                this._size = this.size + 1;
-                                this._count += newNode.count;
-                                traversing = false;
-                                inserted = cur.right;
-                            }
-                            else {
-                                //Traverse the left of the current node
-                                if (cur.right)
-                                    cur = cur.right;
-                            }
-                        }
-                    }
-                    else {
-                        // TODO may need to support undefined inserted
-                    }
-                }
-                else {
-                    traversing = false;
-                }
-            }
+            return;
+        }
+        const orgNodeCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
+        const inserted = super.add(newNode);
+        if (inserted) {
+            this._count += orgNodeCount;
         }
-        if (inserted)
-            this._balancePath(inserted);
         return inserted;
     }
     /**
-     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
+     * Time Complexity: O(k 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.
      */
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
+     * Time Complexity: O(k 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 `addMany` takes an array of keys or nodes and adds them to the TreeMultimap,
-     * returning an array of the inserted nodes.
-     * @param {(BTNKey | N | undefined)[]} keysOrNodes - An array of keys or nodes. Each element can be
-     * of type BTNKey, N, or undefined.
-     * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond to the
-     * keys or nodes being added. It is used to associate data with each key or node being added to the
-     * TreeMultimap. If provided, the length of the `data` array should be the same as the length of the
-     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+     * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
+     * structure.
+     * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
+     * either keys, nodes, or entries.
+     * @returns The method is returning an array of type `N | undefined`.
      */
-    addMany(keysOrNodes, data) {
-        const inserted = [];
-        for (let i = 0; i < keysOrNodes.length; i++) {
-            const keyOrNode = keysOrNodes[i];
-            if (keyOrNode instanceof TreeMultimapNode) {
-                inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
-                continue;
-            }
-            if (keyOrNode === undefined) {
-                inserted.push(this.add(NaN, undefined, 0));
-                continue;
-            }
-            inserted.push(this.add(keyOrNode, data === null || data === void 0 ? void 0 : data[i], 1));
-        }
-        return inserted;
+    addMany(keysOrNodesOrEntries) {
+        return super.addMany(keysOrNodesOrEntries);
     }
     /**
-     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
-     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+     * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
+     * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
      */
     /**
      * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
@@ -203,7 +129,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * values:
      * @returns a boolean value.
      */
-    perfectlyBalance(iterationType = this.options.iterationType) {
+    perfectlyBalance(iterationType = this.iterationType) {
         const sorted = this.dfs(node => node, 'in'), n = sorted.length;
         if (sorted.length < 1)
             return false;
@@ -214,7 +140,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add(midNode.key, midNode.value, midNode.count);
+                this.add([midNode.key, midNode.value], midNode.count);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -230,7 +156,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add(midNode.key, midNode.value, midNode.count);
+                        this.add([midNode.key, midNode.value], midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -240,8 +166,8 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         }
     }
     /**
-     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
-     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+     * Time Complexity: O(k log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each.
+     * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
@@ -297,7 +223,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
                 const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : undefined;
                 if (leftSubTreeRightMost) {
                     const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-                    orgCurrent = this._swap(curr, leftSubTreeRightMost);
+                    orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
                     if (parentOfLeftSubTreeMax) {
                         if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
                             parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
@@ -321,8 +247,8 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return deletedResult;
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete 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.
+     * Time Complexity: O(n log n) - logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node.
+     * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
      */
     /**
      * The clear() function clears the contents of a data structure and sets the count to zero.
@@ -347,7 +273,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * added, or `undefined` if no node was added.
      */
     _addTo(newNode, parent) {
-        parent = this.ensureNotKey(parent);
+        parent = this.ensureNode(parent);
         if (parent) {
             if (parent.left === undefined) {
                 parent.left = newNode;
@@ -374,7 +300,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         }
     }
     /**
-     * The `_swap` function swaps the key, value, count, and height properties between two nodes.
+     * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
      * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
      * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
      * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
@@ -382,9 +308,9 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    _swap(srcNode, destNode) {
-        srcNode = this.ensureNotKey(srcNode);
-        destNode = this.ensureNotKey(destNode);
+    _swapProperties(srcNode, destNode) {
+        srcNode = this.ensureNode(srcNode);
+        destNode = this.ensureNode(destNode);
         if (srcNode && destNode) {
             const { key, value, count, height } = destNode;
             const tempNode = this.createNode(key, value, count);
@@ -403,5 +329,9 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         }
         return undefined;
     }
+    _replaceNode(oldNode, newNode) {
+        newNode.count = oldNode.count + newNode.count;
+        return super._replaceNode(oldNode, newNode);
+    }
 }
 exports.TreeMultimap = TreeMultimap;

package/dist/data-structures/graph/abstract-graph.js

@@ -594,7 +594,7 @@ class AbstractGraph {
             if (vertexOrKey instanceof AbstractVertex)
                 distMap.set(vertexOrKey, Infinity);
         }
-        const heap = new priority_queue_1.PriorityQueue({ comparator: (a, b) => a.key - b.key });
+        const heap = new priority_queue_1.PriorityQueue([], { comparator: (a, b) => a.key - b.key });
         heap.add({ key: 0, value: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);