data-structure-typed 1.47.6 → 1.47.7

package/dist/umd/data-structure-typed.js

@@ -517,13 +517,7 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/hash/hash-map.ts
   var HashMap = class _HashMap {
-    /**
-     * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
-     * @param options - The `options` parameter is an object that contains the `elements` property. The
-     * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
-     */
-    constructor(options = {
-      elements: [],
+    constructor(elements, options = {
       hashFn: (key) => String(key),
       objHashFn: (key) => key
     }) {
@@ -537,7 +531,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "_size", 0);
       this._sentinel = {};
       this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-      const { elements, hashFn, objHashFn } = options;
+      const { hashFn, objHashFn } = options;
       this._hashFn = hashFn;
       this._objHashFn = objHashFn;
       if (elements) {
@@ -844,6 +838,9 @@ var dataStructureTyped = (() => {
         node = node.next;
       }
     }
+    print() {
+      console.log([...this]);
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -6849,55 +6846,27 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/binary-tree/binary-tree.ts
   var BinaryTreeNode = class {
-    /**
-     * Creates a new instance of BinaryTreeNode.
-     * @param {BTNKey} key - The key associated with the node.
-     * @param {V} value - The value stored in the node.
-     */
     constructor(key, value) {
-      /**
-       * The key associated with the node.
-       */
       __publicField(this, "key");
-      /**
-       * The value stored in the node.
-       */
       __publicField(this, "value");
-      /**
-       * The parent node of the current node.
-       */
       __publicField(this, "parent");
       __publicField(this, "_left");
       __publicField(this, "_right");
       this.key = key;
       this.value = value;
     }
-    /**
-     * Get the left child node.
-     */
     get left() {
       return this._left;
     }
-    /**
-     * Set the left child node.
-     * @param {N | null | undefined} v - The left child node.
-     */
     set left(v) {
       if (v) {
         v.parent = this;
       }
       this._left = v;
     }
-    /**
-     * Get the right child node.
-     */
     get right() {
       return this._right;
     }
-    /**
-     * Set the right child node.
-     * @param {N | null | undefined} v - The right child node.
-     */
     set right(v) {
       if (v) {
         v.parent = this;
@@ -6923,8 +6892,13 @@ var dataStructureTyped = (() => {
   };
   var BinaryTree = class _BinaryTree {
     /**
-     * Creates a new instance of BinaryTree.
-     * @param {BinaryTreeOptions} [options] - The options for the binary tree.
+     * The constructor function initializes a binary tree object with optional elements and options.
+     * @param [elements] - An optional iterable of BTNodeExemplar objects. These objects represent the
+     * elements to be added to the binary tree.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the binary tree. In this case, it is of type
+     * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
+     * required.
      */
     constructor(elements, options) {
       __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
@@ -6939,17 +6913,11 @@ var dataStructureTyped = (() => {
       }
       this._size = 0;
       if (elements)
-        this.init(elements);
+        this.addMany(elements);
     }
-    /**
-     * Get the root node of the binary tree.
-     */
     get root() {
       return this._root;
     }
-    /**
-     * Get the number of nodes in the binary tree.
-     */
     get size() {
       return this._size;
     }
@@ -6962,30 +6930,46 @@ var dataStructureTyped = (() => {
     createNode(key, value) {
       return new BinaryTreeNode(key, value);
     }
+    /**
+     * The function creates a binary tree with the given options.
+     * @param [options] - The `options` parameter is an optional object that allows you to customize the
+     * behavior of the `BinaryTree` class. It is of type `Partial<BinaryTreeOptions>`, which means that
+     * you can provide only a subset of the properties defined in the `BinaryTreeOptions` interface.
+     * @returns a new instance of a binary tree.
+     */
     createTree(options) {
       return new _BinaryTree([], __spreadValues({ iterationType: this.iterationType }, options));
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * The function checks if a given value is an entry in a binary tree node.
+     * @param kne - BTNodeExemplar<V, N> - A generic type representing a node in a binary tree. It has
+     * two type parameters V and N, representing the value and node type respectively.
+     * @returns a boolean value.
+     */
+    isEntry(kne) {
+      return Array.isArray(kne) && kne.length === 2;
+    }
+    /**
+     * Time Complexity O(log n) - O(n)
+     * Space Complexity O(1)
+     */
+    /**
+     * Time Complexity O(log n) - O(n)
+     * Space Complexity O(1)
      *
-     * The `add` function adds a new node with a key and value to a binary tree, or updates the value of
-     * an existing node with the same key.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-     * following types:
-     * @param {V} [value] - The value to be associated with the key or node being added to the binary
-     * tree.
-     * @returns The function `add` returns a node (`N`) if it was successfully inserted into the binary
-     * tree, or `null` or `undefined` if the insertion was not successful.
+     * The `add` function adds a new node to a binary tree, either by key or by providing a node object.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be one of the following:
+     * @returns The function `add` returns the inserted node (`N`), `null`, or `undefined`.
      */
-    add(keyOrNode, value) {
+    add(keyOrNodeOrEntry) {
+      let inserted, needInsert;
       const _bfs = (root, newNode) => {
         const queue = new Queue([root]);
         while (queue.size > 0) {
           const cur = queue.shift();
           if (newNode && cur.key === newNode.key) {
-            cur.value = newNode.value;
-            return;
+            this._replaceNode(cur, newNode);
+            return newNode;
           }
           const inserted2 = this._addTo(newNode, cur);
           if (inserted2 !== void 0)
@@ -6996,13 +6980,21 @@ var dataStructureTyped = (() => {
             queue.push(cur.right);
         }
       };
-      let inserted, needInsert;
-      if (keyOrNode === null) {
+      if (keyOrNodeOrEntry === null) {
         needInsert = null;
-      } else if (this.isNodeKey(keyOrNode)) {
-        needInsert = this.createNode(keyOrNode, value);
-      } else if (keyOrNode instanceof BinaryTreeNode) {
-        needInsert = keyOrNode;
+      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
+        needInsert = this.createNode(keyOrNodeOrEntry);
+      } else if (keyOrNodeOrEntry instanceof BinaryTreeNode) {
+        needInsert = keyOrNodeOrEntry;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value] = keyOrNodeOrEntry;
+        if (key === void 0) {
+          return;
+        } else if (key === null) {
+          needInsert = null;
+        } else {
+          needInsert = this.createNode(key, value);
+        }
       } else {
         return;
       }
@@ -7020,35 +7012,27 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
      * Comments: The time complexity for adding a node depends on the depth of the tree. In the best case (when the tree is empty), it's O(1). In the worst case (when the tree is a degenerate tree), it's O(n). The space complexity is constant.
      */
     /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
      *
-     * The `addMany` function takes an array of keys or nodes and an optional array of values, and adds
-     * each key-value pair to a data structure.
-     * @param {(BTNKey | N |null | undefined)[]} keysOrNodes - An array of keys or nodes to be added to
-     * the binary search tree. Each element can be of type `BTNKey` (a key value), `N` (a node), `null`,
-     * or `undefined`.
-     * @param {(V | undefined)[]} [values] - The `values` parameter is an optional array of values that
-     * correspond to the keys or nodes being added. If provided, the values will be associated with the
-     * keys or nodes during the add operation.
-     * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+     * 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<V, N>` objects.
+     * @returns The function `addMany` returns an array of values, where each value is either of type
+     * `N`, `null`, or `undefined`.
      */
-    addMany(keysOrNodes, values) {
-      return keysOrNodes.map((keyOrNode, i) => {
-        if (keyOrNode instanceof BinaryTreeNode) {
-          return this.add(keyOrNode.key, keyOrNode.value);
-        }
-        if (keyOrNode === null) {
-          return this.add(null);
-        }
-        const value = values == null ? void 0 : values[i];
-        return this.add(keyOrNode, value);
-      });
+    addMany(nodes) {
+      const inserted = [];
+      for (const kne of nodes) {
+        inserted.push(this.add(kne));
+      }
+      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.
@@ -7058,17 +7042,13 @@ 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)
      *
-     * The `refill` function clears the binary tree and adds multiple nodes with the given IDs or nodes and optional data.
-     * @param {(BTNKey | N)[]} keysOrNodes - The `keysOrNodes` parameter is an array that can contain either
-     * `BTNKey` or `N` values.
-     * @param {N[] | Array<V>} [values] - The `data` parameter is an optional array of values that will be assigned to
-     * the nodes being added. If provided, the length of the `data` array should be equal to the length of the `keysOrNodes`
-     * array. Each value in the `data` array will be assigned to the
-     * @returns The method is returning a boolean value.
+     * 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(keysOrNodes, values) {
+    refill(nodesOrKeysOrEntries) {
       this.clear();
-      return keysOrNodes.length === this.addMany(keysOrNodes, values).length;
+      this.addMany(nodesOrKeysOrEntries);
     }
     /**
      * Time Complexity: O(n)
@@ -7114,7 +7094,7 @@ var dataStructureTyped = (() => {
           const leftSubTreeRightMost = this.getRightMost(curr.left);
           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;
@@ -7147,8 +7127,8 @@ var dataStructureTyped = (() => {
      * @returns the depth of the `distNode` relative to the `beginRoot`.
      */
     getDepth(distNode, beginRoot = this.root) {
-      distNode = this.ensureNotKey(distNode);
-      beginRoot = this.ensureNotKey(beginRoot);
+      distNode = this.ensureNode(distNode);
+      beginRoot = this.ensureNode(beginRoot);
       let depth = 0;
       while (distNode == null ? void 0 : distNode.parent) {
         if (distNode === beginRoot) {
@@ -7178,7 +7158,7 @@ var dataStructureTyped = (() => {
      * @returns the height of the binary tree.
      */
     getHeight(beginRoot = this.root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return -1;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7224,7 +7204,7 @@ var dataStructureTyped = (() => {
      */
     getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
       var _a, _b, _c;
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return -1;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7311,7 +7291,7 @@ var dataStructureTyped = (() => {
     getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
@@ -7448,7 +7428,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(log n)
      */
     /**
-     * The function `ensureNotKey` returns the node corresponding to the given key if it is a valid node
+     * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
      * @param {BTNKey | N | null | undefined} key - The `key` parameter can be of type `BTNKey`, `N`,
      * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
@@ -7458,7 +7438,7 @@ var dataStructureTyped = (() => {
      * @returns either the node corresponding to the given key if it is a valid node key, or the key
      * itself if it is not a valid node key.
      */
-    ensureNotKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
+    ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
       return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
@@ -7523,7 +7503,7 @@ var dataStructureTyped = (() => {
      */
     getPathToRoot(beginRoot, isReverse = true) {
       const result = [];
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return result;
       while (beginRoot.parent) {
@@ -7552,7 +7532,7 @@ var dataStructureTyped = (() => {
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return beginRoot;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7591,7 +7571,7 @@ var dataStructureTyped = (() => {
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
     getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return beginRoot;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7627,7 +7607,7 @@ var dataStructureTyped = (() => {
      * @returns a boolean value.
      */
     isSubtreeBST(beginRoot, iterationType = this.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return true;
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
@@ -7699,7 +7679,7 @@ var dataStructureTyped = (() => {
      * by the return type of the `callback` function.
      */
     subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       const ans = [];
       if (!beginRoot)
         return ans;
@@ -7797,7 +7777,7 @@ var dataStructureTyped = (() => {
      * @returns an array of values that are the return values of the callback function.
      */
     dfs(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root, iterationType = "ITERATIVE" /* ITERATIVE */, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
@@ -7917,7 +7897,7 @@ var dataStructureTyped = (() => {
      * the breadth-first traversal of a binary tree.
      */
     bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
@@ -7987,7 +7967,7 @@ var dataStructureTyped = (() => {
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
     listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       const levelsNodes = [];
       if (!beginRoot)
         return levelsNodes;
@@ -8039,7 +8019,7 @@ var dataStructureTyped = (() => {
      * @returns The function `getPredecessor` returns a value of type `N | undefined`.
      */
     getPredecessor(node) {
-      node = this.ensureNotKey(node);
+      node = this.ensureNode(node);
       if (!this.isRealNode(node))
         return void 0;
       if (node.left) {
@@ -8061,7 +8041,7 @@ var dataStructureTyped = (() => {
      * after the given node in the inorder traversal of the binary tree.
      */
     getSuccessor(x) {
-      x = this.ensureNotKey(x);
+      x = this.ensureNode(x);
       if (!x)
         return void 0;
       if (x.right) {
@@ -8093,7 +8073,7 @@ var dataStructureTyped = (() => {
      * by the return type of the `callback` function.
      */
     morris(callback = this._defaultOneParamCallback, pattern = "in", beginRoot = this.root) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (beginRoot === null)
         return [];
       const ans = [];
@@ -8200,7 +8180,7 @@ var dataStructureTyped = (() => {
       const newTree = this.createTree();
       for (const [key, value] of this) {
         if (predicate([key, value], this)) {
-          newTree.add(key, value);
+          newTree.add([key, value]);
         }
       }
       return newTree;
@@ -8214,7 +8194,7 @@ var dataStructureTyped = (() => {
     map(callback) {
       const newTree = this.createTree();
       for (const [key, value] of this) {
-        newTree.add(key, callback([key, value], this));
+        newTree.add([key, callback([key, value], this)]);
       }
       return newTree;
     }
@@ -8290,7 +8270,7 @@ var dataStructureTyped = (() => {
      */
     print(beginRoot = this.root, options) {
       const opts = __spreadValues({ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false }, options);
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return;
       if (opts.isShowUndefined)
@@ -8310,18 +8290,6 @@ var dataStructureTyped = (() => {
       };
       display(beginRoot);
     }
-    init(elements) {
-      if (elements) {
-        for (const entryOrKey of elements) {
-          if (Array.isArray(entryOrKey)) {
-            const [key, value] = entryOrKey;
-            this.add(key, value);
-          } else {
-            this.add(entryOrKey);
-          }
-        }
-      }
-    }
     _displayAux(node, options) {
       const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
       const emptyDisplayLayout = [["\u2500"], 1, 0, 0];
@@ -8358,9 +8326,9 @@ var dataStructureTyped = (() => {
      * @param {N} destNode - The destination node to swap.
      * @returns {N} - The destination node after the swap.
      */
-    _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 } = destNode;
         const tempNode = this.createNode(key, value);
@@ -8374,6 +8342,30 @@ var dataStructureTyped = (() => {
       }
       return void 0;
     }
+    /**
+     * The function replaces an old node with a new node in a binary tree.
+     * @param {N} oldNode - The oldNode parameter represents the node that needs to be replaced in the
+     * tree.
+     * @param {N} newNode - The `newNode` parameter is the node that will replace the `oldNode` in the
+     * tree.
+     * @returns The method is returning the newNode.
+     */
+    _replaceNode(oldNode, newNode) {
+      if (oldNode.parent) {
+        if (oldNode.parent.left === oldNode) {
+          oldNode.parent.left = newNode;
+        } else if (oldNode.parent.right === oldNode) {
+          oldNode.parent.right = newNode;
+        }
+      }
+      newNode.left = oldNode.left;
+      newNode.right = oldNode.right;
+      newNode.parent = oldNode.parent;
+      if (this.root === oldNode) {
+        this._root = newNode;
+      }
+      return newNode;
+    }
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null | undefined} newNode - The `newNode` parameter represents the node that you want to add to
@@ -8468,9 +8460,12 @@ var dataStructureTyped = (() => {
   };
   var BST = class _BST extends BinaryTree {
     /**
-     * The constructor function initializes a binary search tree with an optional comparator function.
-     * @param {BSTOptions} [options] - An optional object that contains additional configuration options
-     * for the binary search tree.
+     * This is the constructor function for a binary search tree class in TypeScript, which initializes
+     * the tree with optional elements and options.
+     * @param [elements] - An optional iterable of BTNodeExemplar objects that will be added to the
+     * binary search tree.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the binary search tree. It can have the following properties:
      */
     constructor(elements, options) {
       super([], options);
@@ -8484,11 +8479,8 @@ var dataStructureTyped = (() => {
       }
       this._root = void 0;
       if (elements)
-        this.init(elements);
+        this.addMany(elements);
     }
-    /**
-     * Get the root node of the binary tree.
-     */
     get root() {
       return this._root;
     }
@@ -8503,151 +8495,145 @@ var dataStructureTyped = (() => {
     createNode(key, value) {
       return new BSTNode(key, value);
     }
+    /**
+     * The function creates a new binary search tree with the specified options.
+     * @param [options] - The `options` parameter is an optional object that allows you to customize the
+     * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which is a type
+     * that defines various options for creating a binary search tree.
+     * @returns a new instance of the BST class with the specified options.
+     */
     createTree(options) {
       return new _BST([], __spreadValues({
         iterationType: this.iterationType,
         comparator: this.comparator
       }, options));
     }
+    /**
+     * 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.
+     */
     /**
      * 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 search tree based on the provided key and value.
-     * @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 or node being added to the binary search tree.
-     * @returns The method `add` returns a node (`N`) that was inserted into the binary search tree. If
-     * no node was inserted, it returns `undefined`.
+     * The `add` function adds a new node to a binary search tree, either by key or by providing a node
+     * object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
+     * @returns The method returns either the newly added node (`newNode`) or `undefined` if the input
+     * (`keyOrNodeOrEntry`) is null, undefined, or does not match any of the expected types.
      */
-    add(keyOrNode, value) {
-      if (keyOrNode === null)
+    add(keyOrNodeOrEntry) {
+      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
         return void 0;
-      let inserted;
+      }
       let newNode;
-      if (keyOrNode instanceof BSTNode) {
-        newNode = keyOrNode;
-      } else if (this.isNodeKey(keyOrNode)) {
-        newNode = this.createNode(keyOrNode, value);
+      if (keyOrNodeOrEntry instanceof BSTNode) {
+        newNode = keyOrNodeOrEntry;
+      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
+        newNode = this.createNode(keyOrNodeOrEntry);
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value] = keyOrNodeOrEntry;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          newNode = this.createNode(key, value);
+        }
       } else {
-        newNode = void 0;
+        return;
       }
       if (this.root === void 0) {
         this._setRoot(newNode);
-        this._size = this.size + 1;
-        inserted = this.root;
-      } else {
-        let cur = this.root;
-        let traversing = true;
-        while (traversing) {
-          if (cur !== void 0 && newNode !== void 0) {
-            if (this._compare(cur.key, newNode.key) === "eq" /* eq */) {
-              if (newNode) {
-                cur.value = newNode.value;
-              }
-              traversing = false;
-              inserted = cur;
-            } else if (this._compare(cur.key, newNode.key) === "gt" /* gt */) {
-              if (cur.left === void 0) {
-                if (newNode) {
-                  newNode.parent = cur;
-                }
-                cur.left = newNode;
-                this._size = this.size + 1;
-                traversing = false;
-                inserted = cur.left;
-              } else {
-                if (cur.left)
-                  cur = cur.left;
-              }
-            } else if (this._compare(cur.key, newNode.key) === "lt" /* lt */) {
-              if (cur.right === void 0) {
-                if (newNode) {
-                  newNode.parent = cur;
-                }
-                cur.right = newNode;
-                this._size = this.size + 1;
-                traversing = false;
-                inserted = cur.right;
-              } else {
-                if (cur.right)
-                  cur = cur.right;
-              }
-            }
-          } else {
-            traversing = false;
+        this._size++;
+        return this.root;
+      }
+      let current = this.root;
+      while (current !== void 0) {
+        if (this._compare(current.key, newNode.key) === "eq" /* eq */) {
+          this._replaceNode(current, newNode);
+          return newNode;
+        } else if (this._compare(current.key, newNode.key) === "gt" /* gt */) {
+          if (current.left === void 0) {
+            current.left = newNode;
+            newNode.parent = current;
+            this._size++;
+            return newNode;
+          }
+          current = current.left;
+        } else {
+          if (current.right === void 0) {
+            current.right = newNode;
+            newNode.parent = current;
+            this._size++;
+            return newNode;
           }
+          current = current.right;
         }
       }
-      return inserted;
+      return void 0;
     }
     /**
-     * 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.
+     * 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.
      */
     /**
-     * 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(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 is used to efficiently add multiple keys or nodes with corresponding data
-     * to a binary search tree.
-     * @param {(BTNKey | N | undefined)[]} keysOrNodes - An array of keys or nodes to be added to the
-     * binary search tree. Each element can be of type `BTNKey` (binary tree node key), `N` (binary tree
-     * node), or `undefined`.
-     * @param {(V | undefined)[]} [data] - An optional array of values to associate with the keys or
-     * nodes being added. If provided, the length of the `data` array must be the same as the length of
-     * the `keysOrNodes` 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`.
+     * adding the nodes. The default value is true.
      * @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 search tree. It has a
-     * default value of `this.iterationType`, which means it will use the iteration type specified in the
-     * current instance of the binary search tree
-     * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+     * 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.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
-      function hasNoUndefined(arr) {
-        return arr.indexOf(void 0) === -1;
-      }
-      if (!isBalanceAdd || !hasNoUndefined(keysOrNodes)) {
-        return super.addMany(keysOrNodes, data).map((n) => n != null ? n : void 0);
-      }
+    addMany(keysOrNodesOrEntries, isBalanceAdd = true, iterationType = this.iterationType) {
       const inserted = [];
-      const combinedArr = keysOrNodes.map(
-        (value, index) => [value, data == null ? void 0 : data[index]]
-      );
-      let sorted = [];
-      function _isNodeOrUndefinedTuple(arr) {
-        for (const [keyOrNode] of arr)
-          if (keyOrNode instanceof BSTNode)
-            return true;
-        return false;
+      if (!isBalanceAdd) {
+        for (const kve of keysOrNodesOrEntries) {
+          const nn = this.add(kve);
+          inserted.push(nn);
+        }
+        return inserted;
       }
-      const _isBinaryTreeKeyOrNullTuple = (arr) => {
-        for (const [keyOrNode] of arr)
-          if (this.isNodeKey(keyOrNode))
-            return true;
-        return false;
+      const realBTNExemplars = [];
+      const isRealBTNExemplar = (kve) => {
+        if (kve === void 0 || kve === null)
+          return false;
+        return !(this.isEntry(kve) && (kve[0] === void 0 || kve[0] === null));
       };
-      let sortedKeysOrNodes = [], sortedData = [];
-      if (_isNodeOrUndefinedTuple(combinedArr)) {
-        sorted = combinedArr.sort((a, b) => a[0].key - b[0].key);
-      } else if (_isBinaryTreeKeyOrNullTuple(combinedArr)) {
-        sorted = combinedArr.sort((a, b) => a[0] - b[0]);
-      } else {
-        throw new Error("Invalid input keysOrNodes");
+      for (const kve of keysOrNodesOrEntries) {
+        isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
       }
-      sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
-      sortedData = sorted.map(([, value]) => value);
-      const _dfs = (arr, data2) => {
+      let sorted = [];
+      sorted = realBTNExemplars.sort((a, b) => {
+        let aR, bR;
+        if (this.isEntry(a))
+          aR = a[0];
+        else if (this.isRealNode(a))
+          aR = a.key;
+        else
+          aR = a;
+        if (this.isEntry(b))
+          bR = b[0];
+        else if (this.isRealNode(b))
+          bR = b.key;
+        else
+          bR = b;
+        return aR - bR;
+      });
+      const _dfs = (arr) => {
         if (arr.length === 0)
           return;
         const mid = Math.floor((arr.length - 1) / 2);
-        const newNode = this.add(arr[mid], data2 == null ? void 0 : data2[mid]);
+        const newNode = this.add(arr[mid]);
         inserted.push(newNode);
-        _dfs(arr.slice(0, mid), data2 == null ? void 0 : data2.slice(0, mid));
-        _dfs(arr.slice(mid + 1), data2 == null ? void 0 : data2.slice(mid + 1));
+        _dfs(arr.slice(0, mid));
+        _dfs(arr.slice(mid + 1));
       };
       const _iterate = () => {
         const n = sorted.length;
@@ -8658,7 +8644,7 @@ var dataStructureTyped = (() => {
             const [l, r] = popped;
             if (l <= r) {
               const m = l + Math.floor((r - l) / 2);
-              const newNode = this.add(sortedKeysOrNodes[m], sortedData == null ? void 0 : sortedData[m]);
+              const newNode = this.add(sorted[m]);
               inserted.push(newNode);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
@@ -8667,7 +8653,7 @@ var dataStructureTyped = (() => {
         }
       };
       if (iterationType === "RECURSIVE" /* RECURSIVE */) {
-        _dfs(sortedKeysOrNodes, sortedData);
+        _dfs(sorted);
       } else {
         _iterate();
       }
@@ -8754,7 +8740,7 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
      */
     /**
-     * The function `ensureNotKey` returns the node corresponding to the given key if it is a node key,
+     * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
      * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
      * `undefined`.
@@ -8762,7 +8748,7 @@ var dataStructureTyped = (() => {
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
-    ensureNotKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
+    ensureNode(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
       return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
@@ -8789,7 +8775,7 @@ var dataStructureTyped = (() => {
      * @returns The method returns an array of nodes (`N[]`).
      */
     getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
-      beginRoot = this.ensureNotKey(beginRoot);
+      beginRoot = this.ensureNode(beginRoot);
       if (!beginRoot)
         return [];
       const ans = [];
@@ -8865,7 +8851,7 @@ var dataStructureTyped = (() => {
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
     lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "lt" /* lt */, targetNode = this.root, iterationType = this.iterationType) {
-      targetNode = this.ensureNotKey(targetNode);
+      targetNode = this.ensureNode(targetNode);
       const ans = [];
       if (!targetNode)
         return ans;
@@ -8929,7 +8915,7 @@ var dataStructureTyped = (() => {
             return;
           const m = l + Math.floor((r - l) / 2);
           const midNode = sorted[m];
-          this.add(midNode.key, midNode.value);
+          this.add([midNode.key, midNode.value]);
           buildBalanceBST(l, m - 1);
           buildBalanceBST(m + 1, r);
         };
@@ -8945,7 +8931,7 @@ var dataStructureTyped = (() => {
               const m = l + Math.floor((r - l) / 2);
               const midNode = sorted[m];
               debugger;
-              this.add(midNode.key, midNode.value);
+              this.add([midNode.key, midNode.value]);
               stack.push([m + 1, r]);
               stack.push([l, m - 1]);
             }
@@ -9019,22 +9005,6 @@ var dataStructureTyped = (() => {
       }
       return balanced;
     }
-    /**
-     * Time Complexity: O(n) - Visiting each node once.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-     */
-    init(elements) {
-      if (elements) {
-        for (const entryOrKey of elements) {
-          if (Array.isArray(entryOrKey)) {
-            const [key, value] = entryOrKey;
-            this.add(key, value);
-          } else {
-            this.add(entryOrKey);
-          }
-        }
-      }
-    }
     _setRoot(v) {
       if (v) {
         v.parent = void 0;
@@ -9496,15 +9466,18 @@ var dataStructureTyped = (() => {
   };
   var AVLTree = class _AVLTree extends BST {
     /**
-     * This is a constructor function for an AVL tree data structure in TypeScript.
-     * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
-     * constructor of the AVLTree class. It allows you to customize the behavior of the AVL tree by providing different
-     * options.
+     * The constructor function initializes an AVLTree object with optional elements and options.
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * objects. It represents a collection of elements that will be added to the AVL tree during
+     * initialization.
+     * @param [options] - The `options` parameter is an optional object that allows you to customize the
+     * behavior of the AVL tree. It is of type `Partial<AVLTreeOptions>`, which means that you can
+     * provide only a subset of the properties defined in the `AVLTreeOptions` interface.
      */
     constructor(elements, options) {
       super([], options);
       if (elements)
-        this.init(elements);
+        super.addMany(elements);
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -9518,28 +9491,37 @@ var dataStructureTyped = (() => {
     createNode(key, value) {
       return new AVLTreeNode(key, value);
     }
+    /**
+     * The function creates a new AVL tree with the specified options and returns it.
+     * @param {AVLTreeOptions} [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 AVL tree that is
+     * being created.
+     * @returns a new AVLTree object.
+     */
     createTree(options) {
       return new _AVLTree([], __spreadValues({
         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 (BST) 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(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 class, adds a key-value pair to a data structure, and
-     * balances the structure if necessary.
-     * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be of type
-     * `BTNKey`, `N`, `null`, or `undefined`.
-     * @param {V} [value] - The `value` parameter is the value associated with the key that is being
-     * added to the binary search tree.
-     * @returns The method is returning either a node (N) or undefined.
+     * The function overrides the add method of a binary tree node and balances the tree after inserting
+     * a new node.
+     * @param keyOrNodeOrEntry - The parameter `keyOrNodeOrEntry` can be either a key, a node, or an
+     * entry.
+     * @returns The method is returning either the inserted node or `undefined`.
      */
-    add(keyOrNode, value) {
-      if (keyOrNode === null)
+    add(keyOrNodeOrEntry) {
+      if (keyOrNodeOrEntry === null)
         return void 0;
-      const inserted = super.add(keyOrNode, value);
+      const inserted = super.add(keyOrNodeOrEntry);
       if (inserted)
         this._balancePath(inserted);
       return inserted;
@@ -9575,23 +9557,7 @@ var dataStructureTyped = (() => {
       return deletedResults;
     }
     /**
-     * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete 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.
-     */
-    init(elements) {
-      if (elements) {
-        for (const entryOrKey of elements) {
-          if (Array.isArray(entryOrKey)) {
-            const [key, value] = entryOrKey;
-            this.add(key, value);
-          } else {
-            this.add(entryOrKey);
-          }
-        }
-      }
-    }
-    /**
-     * The `_swap` function swaps the key, value, and height properties between two nodes in a binary
+     * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a binary
      * tree.
      * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node that
      * needs to be swapped with the destination node. It can be of type `BTNKey`, `N`, or `undefined`.
@@ -9600,9 +9566,9 @@ var dataStructureTyped = (() => {
      * @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, height } = destNode;
         const tempNode = this.createNode(key, value);
@@ -9889,6 +9855,10 @@ var dataStructureTyped = (() => {
       B && this._updateHeight(B);
       C && this._updateHeight(C);
     }
+    _replaceNode(oldNode, newNode) {
+      newNode.height = oldNode.height;
+      return super._replaceNode(oldNode, newNode);
+    }
   };
 
   // src/data-structures/binary-tree/rb-tree.ts
@@ -9901,9 +9871,15 @@ var dataStructureTyped = (() => {
   };
   var RedBlackTree = class _RedBlackTree extends 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(elements, options) {
       super([], options);
@@ -9912,7 +9888,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "_size", 0);
       this._root = this.Sentinel;
       if (elements)
-        this.init(elements);
+        super.addMany(elements);
     }
     get root() {
       return this._root;
@@ -9920,9 +9896,28 @@ var dataStructureTyped = (() => {
     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 = 0 /* 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([], __spreadValues({
         iterationType: this.iterationType,
@@ -9932,24 +9927,28 @@ 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 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`.
      */
-    add(keyOrNode, value) {
+    /**
+     * 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(keyOrNodeOrEntry) {
       let node;
-      if (this.isNodeKey(keyOrNode)) {
-        node = this.createNode(keyOrNode, value, 1 /* RED */);
-      } else if (keyOrNode instanceof RedBlackTreeNode) {
-        node = keyOrNode;
-      } else if (keyOrNode === null) {
-        return;
-      } else if (keyOrNode === void 0) {
+      if (this.isNodeKey(keyOrNodeOrEntry)) {
+        node = this.createNode(keyOrNodeOrEntry, void 0, 1 /* RED */);
+      } else if (keyOrNodeOrEntry instanceof RedBlackTreeNode) {
+        node = keyOrNodeOrEntry;
+      } else if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
         return;
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value] = keyOrNodeOrEntry;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          node = this.createNode(key, value, 1 /* RED */);
+        }
       } else {
         return;
       }
@@ -9965,6 +9964,9 @@ var dataStructureTyped = (() => {
           } else if (node.key > x.key) {
             x = x == null ? void 0 : x.right;
           } else {
+            if (node !== x) {
+              this._replaceNode(x, node);
+            }
             return;
           }
         }
@@ -10068,6 +10070,10 @@ var dataStructureTyped = (() => {
     isRealNode(node) {
       return node !== this.Sentinel && node !== void 0;
     }
+    /**
+     * 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)
@@ -10093,7 +10099,7 @@ var dataStructureTyped = (() => {
       var _a;
       if (identifier instanceof 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;
     }
     /**
@@ -10152,18 +10158,6 @@ var dataStructureTyped = (() => {
       this._root = this.Sentinel;
       this._size = 0;
     }
-    init(elements) {
-      if (elements) {
-        for (const entryOrKey of elements) {
-          if (Array.isArray(entryOrKey)) {
-            const [key, value] = entryOrKey;
-            this.add(key, value);
-          } else {
-            this.add(entryOrKey);
-          }
-        }
-      }
-    }
     _setRoot(v) {
       if (v) {
         v.parent = void 0;
@@ -10381,6 +10375,19 @@ var dataStructureTyped = (() => {
       }
       this.root.color = 0 /* 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);
+    }
   };
 
   // src/data-structures/binary-tree/tree-multimap.ts
@@ -10402,20 +10409,17 @@ var dataStructureTyped = (() => {
     }
   };
   var TreeMultimap = class _TreeMultimap extends 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(elements, options) {
       super([], options);
       __publicField(this, "_count", 0);
       if (elements)
-        this.init(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.
@@ -10435,115 +10439,63 @@ var dataStructureTyped = (() => {
         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.
+     * 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 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 void 0;
-      let inserted = void 0, newNode;
-      if (keyOrNode instanceof TreeMultimapNode) {
-        newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
-      } else if (keyOrNode === void 0) {
-        newNode = void 0;
+    add(keyOrNodeOrEntry, count = 1) {
+      let newNode;
+      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
+        return;
+      } else if (keyOrNodeOrEntry instanceof TreeMultimapNode) {
+        newNode = keyOrNodeOrEntry;
+      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
+        newNode = this.createNode(keyOrNodeOrEntry, void 0, count);
+      } else if (this.isEntry(keyOrNodeOrEntry)) {
+        const [key, value] = keyOrNodeOrEntry;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          newNode = this.createNode(key, value, count);
+        }
       } else {
-        newNode = this.createNode(keyOrNode, value, count);
+        return;
       }
-      if (!this.root) {
-        this._setRoot(newNode);
-        this._size = this.size + 1;
-        if (newNode)
-          this._count += newNode.count;
-        inserted = this.root;
-      } else {
-        let cur = this.root;
-        let traversing = true;
-        while (traversing) {
-          if (cur) {
-            if (newNode) {
-              if (this._compare(cur.key, newNode.key) === "eq" /* 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) === "gt" /* gt */) {
-                if (cur.left === void 0) {
-                  cur.left = newNode;
-                  this._size = this.size + 1;
-                  this._count += newNode.count;
-                  traversing = false;
-                  inserted = cur.left;
-                } else {
-                  if (cur.left)
-                    cur = cur.left;
-                }
-              } else if (this._compare(cur.key, newNode.key) === "lt" /* lt */) {
-                if (cur.right === void 0) {
-                  cur.right = newNode;
-                  this._size = this.size + 1;
-                  this._count += newNode.count;
-                  traversing = false;
-                  inserted = cur.right;
-                } else {
-                  if (cur.right)
-                    cur = cur.right;
-                }
-              }
-            } else {
-            }
-          } else {
-            traversing = false;
-          }
-        }
+      const orgNodeCount = (newNode == null ? 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(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.
+     * 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 === void 0) {
-          inserted.push(this.add(NaN, void 0, 0));
-          continue;
-        }
-        inserted.push(this.add(keyOrNode, data == null ? void 0 : data[i], 1));
-      }
-      return inserted;
+    addMany(keysOrNodesOrEntries) {
+      return super.addMany(keysOrNodesOrEntries);
     }
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
@@ -10571,7 +10523,7 @@ var dataStructureTyped = (() => {
             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);
         };
@@ -10586,7 +10538,7 @@ var dataStructureTyped = (() => {
             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]);
             }
@@ -10649,7 +10601,7 @@ var dataStructureTyped = (() => {
           const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : void 0;
           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;
@@ -10681,22 +10633,6 @@ var dataStructureTyped = (() => {
       super.clear();
       this._count = 0;
     }
-    /**
-     * 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.
-     */
-    init(elements) {
-      if (elements) {
-        for (const entryOrKey of elements) {
-          if (Array.isArray(entryOrKey)) {
-            const [key, value] = entryOrKey;
-            this.add(key, value);
-          } else {
-            this.add(entryOrKey);
-          }
-        }
-      }
-    }
     /**
      * 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.
@@ -10713,7 +10649,7 @@ var dataStructureTyped = (() => {
      * added, or `undefined` if no node was added.
      */
     _addTo(newNode, parent) {
-      parent = this.ensureNotKey(parent);
+      parent = this.ensureNode(parent);
       if (parent) {
         if (parent.left === void 0) {
           parent.left = newNode;
@@ -10737,7 +10673,7 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * 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
@@ -10745,9 +10681,9 @@ var dataStructureTyped = (() => {
      * @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);
@@ -10766,6 +10702,10 @@ var dataStructureTyped = (() => {
       }
       return void 0;
     }
+    _replaceNode(oldNode, newNode) {
+      newNode.count = oldNode.count + newNode.count;
+      return super._replaceNode(oldNode, newNode);
+    }
   };
 
   // src/data-structures/tree/tree.ts
@@ -11416,16 +11356,21 @@ var dataStructureTyped = (() => {
   };
   var Trie = class _Trie {
     constructor(words, caseSensitive = true) {
+      __publicField(this, "_size");
       __publicField(this, "_caseSensitive");
       __publicField(this, "_root");
       this._root = new TrieNode("");
       this._caseSensitive = caseSensitive;
+      this._size = 0;
       if (words) {
-        for (const i of words) {
-          this.add(i);
+        for (const word of words) {
+          this.add(word);
         }
       }
     }
+    get size() {
+      return this._size;
+    }
     get caseSensitive() {
       return this._caseSensitive;
     }
@@ -11447,6 +11392,7 @@ var dataStructureTyped = (() => {
     add(word) {
       word = this._caseProcess(word);
       let cur = this.root;
+      let isNewWord = false;
       for (const c of word) {
         let nodeC = cur.children.get(c);
         if (!nodeC) {
@@ -11455,8 +11401,12 @@ var dataStructureTyped = (() => {
         }
         cur = nodeC;
       }
-      cur.isEnd = true;
-      return true;
+      if (!cur.isEnd) {
+        isNewWord = true;
+        cur.isEnd = true;
+        this._size++;
+      }
+      return isNewWord;
     }
     /**
      * Time Complexity: O(M), where M is the length of the input word.
@@ -11522,6 +11472,9 @@ var dataStructureTyped = (() => {
         return false;
       };
       dfs(this.root, 0);
+      if (isDeleted) {
+        this._size--;
+      }
       return isDeleted;
     }
     /**
@@ -11744,6 +11697,9 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    print() {
+      console.log([...this]);
+    }
     /**
      * Time Complexity: O(M), where M is the length of the input string.
      * Space Complexity: O(1) - Constant space.