data-structure-typed 1.47.5 → 1.47.6

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

@@ -886,13 +886,17 @@ var dataStructureTyped = (() => {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor() {
+    constructor(elements) {
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_length");
       this._head = null;
       this._tail = null;
       this._length = 0;
+      if (elements) {
+        for (const el of elements)
+          this.push(el);
+      }
     }
     get head() {
       return this._head;
@@ -1568,6 +1572,9 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    print() {
+      console.log([...this]);
+    }
   };
 
   // src/data-structures/linked-list/doubly-linked-list.ts
@@ -1590,13 +1597,18 @@ var dataStructureTyped = (() => {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor() {
+    constructor(elements) {
       __publicField(this, "_head");
       __publicField(this, "_tail");
       __publicField(this, "_length");
       this._head = null;
       this._tail = null;
       this._length = 0;
+      if (elements) {
+        for (const el of elements) {
+          this.push(el);
+        }
+      }
     }
     get head() {
       return this._head;
@@ -2325,6 +2337,9 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    print() {
+      console.log([...this]);
+    }
   };
 
   // src/data-structures/linked-list/skip-linked-list.ts
@@ -2585,7 +2600,12 @@ var dataStructureTyped = (() => {
      */
     constructor(elements) {
       __publicField(this, "_elements");
-      this._elements = Array.isArray(elements) ? elements : [];
+      this._elements = [];
+      if (elements) {
+        for (const el of elements) {
+          this.push(el);
+        }
+      }
     }
     get elements() {
       return this._elements;
@@ -2708,7 +2728,7 @@ var dataStructureTyped = (() => {
      * @returns An iterator object.
      */
     *[Symbol.iterator]() {
-      for (let i = this.elements.length - 1; i >= 0; i--) {
+      for (let i = 0; i < this.elements.length; i++) {
         yield this.elements[i];
       }
     }
@@ -2752,6 +2772,9 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    print() {
+      console.log([...this]);
+    }
   };
 
   // src/data-structures/queue/queue.ts
@@ -3012,6 +3035,9 @@ var dataStructureTyped = (() => {
     clone() {
       return new _Queue(this.nodes.slice(this.offset));
     }
+    print() {
+      console.log([...this]);
+    }
     *[Symbol.iterator]() {
       for (const item of this.nodes) {
         yield item;
@@ -3845,6 +3871,9 @@ var dataStructureTyped = (() => {
       }
       return accumulator;
     }
+    print() {
+      console.log([...this]);
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -4075,21 +4104,32 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/heap/heap.ts
   var Heap = class _Heap {
-    constructor(options) {
+    constructor(elements, options) {
+      __publicField(this, "options");
       __publicField(this, "_elements", []);
-      __publicField(this, "_comparator");
-      this._comparator = options.comparator;
-      if (options.elements && options.elements.length > 0) {
-        this._elements = options.elements;
-        this.fix();
+      const defaultComparator = (a, b) => {
+        if (!(typeof a === "number" && typeof b === "number")) {
+          throw new Error("The a, b params of compare function must be number");
+        } else {
+          return a - b;
+        }
+      };
+      if (options) {
+        this.options = options;
+      } else {
+        this.options = {
+          comparator: defaultComparator
+        };
+      }
+      if (elements) {
+        for (const el of elements) {
+          this.push(el);
+        }
       }
     }
     get elements() {
       return this._elements;
     }
-    get comparator() {
-      return this._comparator;
-    }
     /**
      * Get the size (number of elements) of the heap.
      */
@@ -4107,10 +4147,11 @@ var dataStructureTyped = (() => {
     /**
      * Static method that creates a binary heap from an array of elements and a comparison function.
      * @returns A new Heap instance.
+     * @param elements
      * @param options
      */
-    static heapify(options) {
-      return new _Heap(options);
+    static heapify(elements, options) {
+      return new _Heap(elements, options);
     }
     /**
      * Time Complexity: O(log n), where n is the number of elements in the heap.
@@ -4319,7 +4360,7 @@ var dataStructureTyped = (() => {
      * @returns A new Heap instance containing the same elements.
      */
     clone() {
-      const clonedHeap = new _Heap({ comparator: this.comparator });
+      const clonedHeap = new _Heap([], this.options);
       clonedHeap._elements = [...this.elements];
       return clonedHeap;
     }
@@ -4371,7 +4412,7 @@ var dataStructureTyped = (() => {
       }
     }
     filter(predicate) {
-      const filteredHeap = new _Heap({ comparator: this.comparator });
+      const filteredHeap = new _Heap([], this.options);
       let index = 0;
       for (const el of this) {
         if (predicate(el, index, this)) {
@@ -4382,7 +4423,7 @@ var dataStructureTyped = (() => {
       return filteredHeap;
     }
     map(callback, comparator) {
-      const mappedHeap = new _Heap({ comparator });
+      const mappedHeap = new _Heap([], { comparator });
       let index = 0;
       for (const el of this) {
         mappedHeap.add(callback(el, index, this));
@@ -4403,6 +4444,13 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
+    print() {
+      console.log([...this]);
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -4415,17 +4463,13 @@ var dataStructureTyped = (() => {
       while (index > 0) {
         const parent = index - 1 >> 1;
         const parentItem = this.elements[parent];
-        if (this._comparator(parentItem, element) <= 0)
+        if (this.options.comparator(parentItem, element) <= 0)
           break;
         this.elements[index] = parentItem;
         index = parent;
       }
       this.elements[index] = element;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -4440,11 +4484,11 @@ var dataStructureTyped = (() => {
         let left = index << 1 | 1;
         const right = left + 1;
         let minItem = this.elements[left];
-        if (right < this.elements.length && this._comparator(minItem, this.elements[right]) > 0) {
+        if (right < this.elements.length && this.options.comparator(minItem, this.elements[right]) > 0) {
           left = right;
           minItem = this.elements[right];
         }
-        if (this._comparator(minItem, element) >= 0)
+        if (this.options.comparator(minItem, element) >= 0)
           break;
         this.elements[index] = minItem;
         index = left;
@@ -4473,7 +4517,7 @@ var dataStructureTyped = (() => {
       __publicField(this, "_min");
       __publicField(this, "_comparator");
       this.clear();
-      this._comparator = comparator || this.defaultComparator;
+      this._comparator = comparator || this._defaultComparator;
       if (typeof this.comparator !== "function") {
         throw new Error("FibonacciHeap constructor: given comparator should be a function.");
       }
@@ -4642,7 +4686,7 @@ var dataStructureTyped = (() => {
         this._root = void 0;
       } else {
         this._min = z.right;
-        this.consolidate();
+        this._consolidate();
       }
       this._size--;
       return z.element;
@@ -4678,27 +4722,27 @@ var dataStructureTyped = (() => {
       this._size += heapToMerge.size;
       heapToMerge.clear();
     }
+    /**
+     * Create a new node.
+     * @param element
+     * @protected
+     */
+    createNode(element) {
+      return new FibonacciHeapNode(element);
+    }
     /**
      * Default comparator function used by the heap.
      * @param {E} a
      * @param {E} b
      * @protected
      */
-    defaultComparator(a, b) {
+    _defaultComparator(a, b) {
       if (a < b)
         return -1;
       if (a > b)
         return 1;
       return 0;
     }
-    /**
-     * Create a new node.
-     * @param element
-     * @protected
-     */
-    createNode(element) {
-      return new FibonacciHeapNode(element);
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -4753,7 +4797,7 @@ var dataStructureTyped = (() => {
      * @param x
      * @protected
      */
-    link(y, x) {
+    _link(y, x) {
       this.removeFromRoot(y);
       y.left = y;
       y.right = y;
@@ -4772,7 +4816,7 @@ var dataStructureTyped = (() => {
      * Remove and return the top element (smallest or largest element) from the heap.
      * @protected
      */
-    consolidate() {
+    _consolidate() {
       const A = new Array(this.size);
       const elements = this.consumeLinkedList(this.root);
       let x, y, d, t;
@@ -4786,7 +4830,7 @@ var dataStructureTyped = (() => {
             x = y;
             y = t;
           }
-          this.link(y, x);
+          this._link(y, x);
           A[d] = void 0;
           d++;
         }
@@ -4802,7 +4846,7 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/heap/max-heap.ts
   var MaxHeap = class extends Heap {
-    constructor(options = {
+    constructor(elements, options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -4811,13 +4855,13 @@ var dataStructureTyped = (() => {
         }
       }
     }) {
-      super(options);
+      super(elements, options);
     }
   };
 
   // src/data-structures/heap/min-heap.ts
   var MinHeap = class extends Heap {
-    constructor(options = {
+    constructor(elements, options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -4826,20 +4870,20 @@ var dataStructureTyped = (() => {
         }
       }
     }) {
-      super(options);
+      super(elements, options);
     }
   };
 
   // src/data-structures/priority-queue/priority-queue.ts
   var PriorityQueue = class extends Heap {
-    constructor(options) {
-      super(options);
+    constructor(elements, options) {
+      super(elements, options);
     }
   };
 
   // src/data-structures/priority-queue/min-priority-queue.ts
   var MinPriorityQueue = class extends PriorityQueue {
-    constructor(options = {
+    constructor(elements, options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -4848,13 +4892,13 @@ var dataStructureTyped = (() => {
         }
       }
     }) {
-      super(options);
+      super(elements, options);
     }
   };
 
   // src/data-structures/priority-queue/max-priority-queue.ts
   var MaxPriorityQueue = class extends PriorityQueue {
-    constructor(options = {
+    constructor(elements, options = {
       comparator: (a, b) => {
         if (!(typeof a === "number" && typeof b === "number")) {
           throw new Error("The a, b params of compare function must be number");
@@ -4863,7 +4907,7 @@ var dataStructureTyped = (() => {
         }
       }
     }) {
-      super(options);
+      super(elements, options);
     }
   };
 
@@ -5446,7 +5490,7 @@ var dataStructureTyped = (() => {
         if (vertexOrKey instanceof AbstractVertex)
           distMap.set(vertexOrKey, Infinity);
       }
-      const heap = new PriorityQueue({ comparator: (a, b) => a.key - b.key });
+      const heap = new PriorityQueue([], { comparator: (a, b) => a.key - b.key });
       heap.add({ key: 0, value: srcVertex });
       distMap.set(srcVertex, 0);
       preMap.set(srcVertex, null);
@@ -6772,10 +6816,10 @@ var dataStructureTyped = (() => {
   };
 
   // src/types/data-structures/binary-tree/binary-tree.ts
-  var IterationType = /* @__PURE__ */ ((IterationType2) => {
-    IterationType2["ITERATIVE"] = "ITERATIVE";
-    IterationType2["RECURSIVE"] = "RECURSIVE";
-    return IterationType2;
+  var IterationType = /* @__PURE__ */ ((IterationType3) => {
+    IterationType3["ITERATIVE"] = "ITERATIVE";
+    IterationType3["RECURSIVE"] = "RECURSIVE";
+    return IterationType3;
   })(IterationType || {});
   var FamilyPosition = /* @__PURE__ */ ((FamilyPosition2) => {
     FamilyPosition2["ROOT"] = "ROOT";
@@ -6882,17 +6926,20 @@ var dataStructureTyped = (() => {
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
-    constructor(options) {
-      __publicField(this, "options");
+    constructor(elements, options) {
+      __publicField(this, "iterationType", "ITERATIVE" /* ITERATIVE */);
       __publicField(this, "_root");
       __publicField(this, "_size");
       __publicField(this, "_defaultOneParamCallback", (node) => node.key);
       if (options) {
-        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */ }, options);
-      } else {
-        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */ };
+        const { iterationType } = options;
+        if (iterationType) {
+          this.iterationType = iterationType;
+        }
       }
       this._size = 0;
+      if (elements)
+        this.init(elements);
     }
     /**
      * Get the root node of the binary tree.
@@ -6916,13 +6963,8 @@ var dataStructureTyped = (() => {
       return new BinaryTreeNode(key, value);
     }
     createTree(options) {
-      return new _BinaryTree(__spreadValues(__spreadValues({}, this.options), options));
+      return new _BinaryTree([], __spreadValues({ iterationType: this.iterationType }, options));
     }
-    /**
-     * Time Complexity: O(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(n)
      * Space Complexity: O(1)
@@ -6978,8 +7020,9 @@ var dataStructureTyped = (() => {
       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.
+     * Time Complexity: O(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.
@@ -7027,10 +7070,6 @@ var dataStructureTyped = (() => {
       this.clear();
       return keysOrNodes.length === this.addMany(keysOrNodes, values).length;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -7122,8 +7161,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -7139,7 +7177,7 @@ var dataStructureTyped = (() => {
      * values:
      * @returns the height of the binary tree.
      */
-    getHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getHeight(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return -1;
@@ -7184,7 +7222,7 @@ var dataStructureTyped = (() => {
      * to calculate the minimum height of a binary tree. It can have two possible values:
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
-    getMinHeight(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
       var _a, _b, _c;
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
@@ -7229,6 +7267,7 @@ var dataStructureTyped = (() => {
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
+     * Best Case - O(log n) (when using recursive iterationType), Worst Case - O(n) (when using iterative iterationType)
      */
     /**
      * Time Complexity: O(n)
@@ -7244,10 +7283,6 @@ var dataStructureTyped = (() => {
     isPerfectlyBalanced(beginRoot = this.root) {
       return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
@@ -7273,7 +7308,7 @@ var dataStructureTyped = (() => {
      * traverse the binary tree. It can have two possible values:
      * @returns an array of nodes of type `N`.
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.options.iterationType) {
+    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);
@@ -7310,10 +7345,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n).
-     */
     /**
      * Time Complexity: O(n)
      *
@@ -7334,15 +7365,11 @@ var dataStructureTyped = (() => {
      * be performed in a pre-order, in-order, or post-order manner.
      * @returns a boolean value.
      */
-    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    has(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
       return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -7364,7 +7391,7 @@ var dataStructureTyped = (() => {
      * nodes are visited during the search.
      * @returns a value of type `N | null | 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 ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
@@ -7416,6 +7443,10 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * The function `ensureNotKey` returns the node corresponding to the given key if it is a valid node
      * key, otherwise it returns the key itself.
@@ -7430,10 +7461,6 @@ var dataStructureTyped = (() => {
     ensureNotKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
       return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -7456,12 +7483,16 @@ var dataStructureTyped = (() => {
      * @returns The value of the node with the given identifier is being returned. If the node is not
      * found, `undefined` is returned.
      */
-    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType) {
+    get(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
       var _a, _b;
       if ((!callback || callback === this._defaultOneParamCallback) && identifier instanceof BinaryTreeNode)
         callback = (node) => node;
       return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) == null ? void 0 : _a.value) != null ? _b : void 0;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
     /**
      * Clear the binary tree, removing all nodes.
      */
@@ -7476,10 +7507,6 @@ var dataStructureTyped = (() => {
     isEmpty() {
       return this.size === 0;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
-     */
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -7508,7 +7535,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      */
     /**
      * Time Complexity: O(log n)
@@ -7524,7 +7551,7 @@ var dataStructureTyped = (() => {
      * @returns The function `getLeftMost` returns the leftmost node (`N`) in the binary tree. If there
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
-    getLeftMost(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return beginRoot;
@@ -7563,7 +7590,7 @@ var dataStructureTyped = (() => {
      * @returns The function `getRightMost` returns the rightmost node (`N`) in a binary tree. If there
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
-    getRightMost(beginRoot = this.root, iterationType = this.options.iterationType) {
+    getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return beginRoot;
@@ -7584,7 +7611,7 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      */
     /**
@@ -7599,7 +7626,7 @@ var dataStructureTyped = (() => {
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot, iterationType = this.options.iterationType) {
+    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return true;
@@ -7644,15 +7671,11 @@ var dataStructureTyped = (() => {
      * expected to be
      * @returns a boolean value.
      */
-    isBST(iterationType = this.options.iterationType) {
+    isBST(iterationType = this.iterationType) {
       if (this.root === null)
         return true;
       return this.isSubtreeBST(this.root, iterationType);
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(log n)
@@ -7675,7 +7698,7 @@ var dataStructureTyped = (() => {
      * the `callback` function on each node in the subtree. The type of the array elements is determined
      * by the return type of the `callback` function.
      */
-    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
+    subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
       beginRoot = this.ensureNotKey(beginRoot);
       const ans = [];
       if (!beginRoot)
@@ -7712,6 +7735,10 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(log n)
+     */
     /**
      * The function checks if a given node is a real node by verifying if it is an instance of
      * BinaryTreeNode and its key is not NaN.
@@ -7746,10 +7773,6 @@ var dataStructureTyped = (() => {
     isNodeKey(potentialKey) {
       return typeof potentialKey === "number";
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -7872,10 +7895,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -7897,7 +7916,7 @@ var dataStructureTyped = (() => {
      * @returns an array of values that are the result of invoking the callback function on each node in
      * the breadth-first traversal of a binary tree.
      */
-    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
+    bfs(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return [];
@@ -7946,10 +7965,6 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -7971,7 +7986,7 @@ var dataStructureTyped = (() => {
      * be excluded
      * @returns The function `listLevels` returns a two-dimensional array of type `ReturnType<C>[][]`.
      */
-    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.options.iterationType, includeNull = false) {
+    listLevels(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
       beginRoot = this.ensureNotKey(beginRoot);
       const levelsNodes = [];
       if (!beginRoot)
@@ -8059,10 +8074,6 @@ var dataStructureTyped = (() => {
       }
       return y;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(1)
-     */
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)
@@ -8162,6 +8173,10 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(1)
+     */
     /**
      * The `forEach` function iterates over each entry in a tree and calls a callback function with the
      * entry and the tree as arguments.
@@ -8190,14 +8205,6 @@ var dataStructureTyped = (() => {
       }
       return newTree;
     }
-    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
-    //   const newTree = this.createTree();
-    //   for (const [key, value] of this) {
-    //     newTree.add(key, callback([key, value], this));
-    //   }
-    //   return newTree;
-    // }
     /**
      * The `map` function creates a new tree by applying a callback function to each entry in the current
      * tree.
@@ -8211,6 +8218,14 @@ var dataStructureTyped = (() => {
       }
       return newTree;
     }
+    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
+    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
+    //   const newTree = this.createTree();
+    //   for (const [key, value] of this) {
+    //     newTree.add(key, callback([key, value], this));
+    //   }
+    //   return newTree;
+    // }
     /**
      * The `reduce` function iterates over the entries of a tree and applies a callback function to each
      * entry, accumulating a single value.
@@ -8242,7 +8257,7 @@ var dataStructureTyped = (() => {
     *[Symbol.iterator](node = this.root) {
       if (!node)
         return;
-      if (this.options.iterationType === "ITERATIVE" /* ITERATIVE */) {
+      if (this.iterationType === "ITERATIVE" /* ITERATIVE */) {
         const stack = [];
         let current = node;
         while (current || stack.length > 0) {
@@ -8295,6 +8310,18 @@ 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];
@@ -8445,16 +8472,19 @@ var dataStructureTyped = (() => {
      * @param {BSTOptions} [options] - An optional object that contains additional configuration options
      * for the binary search tree.
      */
-    constructor(options) {
-      super(options);
-      __publicField(this, "options");
+    constructor(elements, options) {
+      super([], options);
       __publicField(this, "_root");
+      __publicField(this, "comparator", (a, b) => a - b);
       if (options) {
-        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
-      } else {
-        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
+        const { comparator } = options;
+        if (comparator) {
+          this.comparator = comparator;
+        }
       }
       this._root = void 0;
+      if (elements)
+        this.init(elements);
     }
     /**
      * Get the root node of the binary tree.
@@ -8474,12 +8504,11 @@ var dataStructureTyped = (() => {
       return new BSTNode(key, value);
     }
     createTree(options) {
-      return new _BST(__spreadValues(__spreadValues({}, this.options), 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.
@@ -8554,8 +8583,8 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
+     * Space Complexity: O(1) - Constant space is used.
      */
     /**
      * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
@@ -8577,7 +8606,7 @@ var dataStructureTyped = (() => {
      * current instance of the binary search tree
      * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
      */
-    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.options.iterationType) {
+    addMany(keysOrNodes, data, isBalanceAdd = true, iterationType = this.iterationType) {
       function hasNoUndefined(arr) {
         return arr.indexOf(void 0) === -1;
       }
@@ -8645,8 +8674,8 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
+     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+     * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
@@ -8663,7 +8692,7 @@ var dataStructureTyped = (() => {
      * the key of the leftmost node if the comparison result is greater than, and the key of the
      * rightmost node otherwise. If no node is found, it returns 0.
      */
-    lastKey(beginRoot = this.root, iterationType = this.options.iterationType) {
+    lastKey(beginRoot = this.root, iterationType = this.iterationType) {
       var _a, _b, _c, _d, _e, _f;
       if (this._compare(0, 1) === "lt" /* lt */)
         return (_b = (_a = this.getRightMost(beginRoot, iterationType)) == null ? void 0 : _a.key) != null ? _b : 0;
@@ -8674,7 +8703,7 @@ var dataStructureTyped = (() => {
     }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Space Complexity: O(1) - Constant space is used.
      */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
@@ -8720,6 +8749,10 @@ var dataStructureTyped = (() => {
         }
       }
     }
+    /**
+     * Time Complexity: O(log n) - Average case for a balanced tree.
+     * 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,
      * otherwise it returns the key itself.
@@ -8732,10 +8765,6 @@ var dataStructureTyped = (() => {
     ensureNotKey(key, iterationType = "ITERATIVE" /* ITERATIVE */) {
       return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
-     */
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -8759,7 +8788,7 @@ var dataStructureTyped = (() => {
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`N[]`).
      */
-    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.options.iterationType) {
+    getNodes(identifier, callback = this._defaultOneParamCallback, onlyOne = false, beginRoot = this.root, iterationType = this.iterationType) {
       beginRoot = this.ensureNotKey(beginRoot);
       if (!beginRoot)
         return [];
@@ -8835,7 +8864,7 @@ var dataStructureTyped = (() => {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `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.options.iterationType) {
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = "lt" /* lt */, targetNode = this.root, iterationType = this.iterationType) {
       targetNode = this.ensureNotKey(targetNode);
       const ans = [];
       if (!targetNode)
@@ -8875,17 +8904,8 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Balancing Adjustment:
-     * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
-     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
-     *
-     * Use Cases and Efficiency:
-     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
-     * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
-     */
-    /**
-     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
+     * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
+     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
      */
     /**
      * Time Complexity: O(n) - Building a balanced tree from a sorted array.
@@ -8898,7 +8918,7 @@ var dataStructureTyped = (() => {
      * values:
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
-    perfectlyBalance(iterationType = this.options.iterationType) {
+    perfectlyBalance(iterationType = this.iterationType) {
       const sorted = this.dfs((node) => node, "in"), n = sorted.length;
       this.clear();
       if (sorted.length < 1)
@@ -8935,8 +8955,17 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(n) - Visiting each node once.
-     * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
+     * Balancing Adjustment:
+     * Perfectly Balanced Binary Tree: Since the balance of a perfectly balanced binary tree is already fixed, no additional balancing adjustment is needed. Any insertion or deletion operation will disrupt the perfect balance, often requiring a complete reconstruction of the tree.
+     * AVL Tree: After insertion or deletion operations, an AVL tree performs rotation adjustments based on the balance factor of nodes to restore the tree's balance. These rotations can be left rotations, right rotations, left-right rotations, or right-left rotations, performed as needed.
+     *
+     * Use Cases and Efficiency:
+     * Perfectly Balanced Binary Tree: Perfectly balanced binary trees are typically used in specific scenarios such as complete binary heaps in heap sort or certain types of Huffman trees. However, they are not suitable for dynamic operations requiring frequent insertions and deletions, as these operations often necessitate full tree reconstruction.
+     * AVL Tree: AVL trees are well-suited for scenarios involving frequent searching, insertion, and deletion operations. Through rotation adjustments, AVL trees maintain their balance, ensuring average and worst-case time complexity of O(log n).
+     */
+    /**
+     * Time Complexity: O(n) - Building a balanced tree from a sorted array.
+     * Space Complexity: O(n) - Additional space is required for the sorted array.
      */
     /**
      * Time Complexity: O(n) - Visiting each node once.
@@ -8947,7 +8976,7 @@ var dataStructureTyped = (() => {
      * to check if the AVL tree is balanced. It can have two possible values:
      * @returns a boolean value.
      */
-    isAVLBalanced(iterationType = this.options.iterationType) {
+    isAVLBalanced(iterationType = this.iterationType) {
       var _a, _b;
       if (!this.root)
         return true;
@@ -8990,6 +9019,22 @@ 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;
@@ -9005,7 +9050,7 @@ var dataStructureTyped = (() => {
      * than), CP.lt (less than), or CP.eq (equal).
      */
     _compare(a, b) {
-      const compared = this.options.comparator(a, b);
+      const compared = this.comparator(a, b);
       if (compared > 0)
         return "gt" /* gt */;
       else if (compared < 0)
@@ -9456,14 +9501,10 @@ var dataStructureTyped = (() => {
      * constructor of the AVLTree class. It allows you to customize the behavior of the AVL tree by providing different
      * options.
      */
-    constructor(options) {
-      super(options);
-      __publicField(this, "options");
-      if (options) {
-        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
-      } else {
-        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
-      }
+    constructor(elements, options) {
+      super([], options);
+      if (elements)
+        this.init(elements);
     }
     /**
      * The function creates a new AVL tree node with the specified key and value.
@@ -9478,12 +9519,11 @@ var dataStructureTyped = (() => {
       return new AVLTreeNode(key, value);
     }
     createTree(options) {
-      return new _AVLTree(__spreadValues(__spreadValues({}, this.options), 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.
@@ -9505,7 +9545,7 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-     * 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.
+     * 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.
      */
     /**
@@ -9534,6 +9574,22 @@ 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
      * tree.
@@ -9849,18 +9905,14 @@ var dataStructureTyped = (() => {
      * @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.
      */
-    constructor(options) {
-      super(options);
+    constructor(elements, options) {
+      super([], options);
       __publicField(this, "Sentinel", new RedBlackTreeNode(NaN));
-      __publicField(this, "options");
       __publicField(this, "_root");
       __publicField(this, "_size", 0);
-      if (options) {
-        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
-      } else {
-        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
-      }
       this._root = this.Sentinel;
+      if (elements)
+        this.init(elements);
     }
     get root() {
       return this._root;
@@ -9872,12 +9924,11 @@ var dataStructureTyped = (() => {
       return new RedBlackTreeNode(key, value, color);
     }
     createTree(options) {
-      return new _RedBlackTree(__spreadValues(__spreadValues({}, this.options), options));
+      return new _RedBlackTree([], __spreadValues({
+        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)
@@ -10010,13 +10061,13 @@ var dataStructureTyped = (() => {
       helper(this.root);
       return ans;
     }
-    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)
      */
+    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)
@@ -10038,7 +10089,7 @@ var dataStructureTyped = (() => {
      * `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 BinaryTreeNode)
         callback = (node) => node;
@@ -10093,10 +10144,26 @@ var dataStructureTyped = (() => {
       }
       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;
     }
+    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;
@@ -10341,15 +10408,11 @@ var dataStructureTyped = (() => {
      * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
      * TreeMultimap.
      */
-    constructor(options = { iterationType: "ITERATIVE" /* ITERATIVE */ }) {
-      super(options);
-      __publicField(this, "options");
+    constructor(elements, options) {
+      super([], options);
       __publicField(this, "_count", 0);
-      if (options) {
-        this.options = __spreadValues({ iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b }, options);
-      } else {
-        this.options = { iterationType: "ITERATIVE" /* ITERATIVE */, comparator: (a, b) => a - b };
-      }
+      if (elements)
+        this.init(elements);
     }
     get count() {
       return this._count;
@@ -10367,12 +10430,11 @@ var dataStructureTyped = (() => {
       return new TreeMultimapNode(key, value, count);
     }
     createTree(options) {
-      return new _TreeMultimap(__spreadValues(__spreadValues({}, this.options), options));
+      return new _TreeMultimap([], __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 (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.
@@ -10451,8 +10513,8 @@ var dataStructureTyped = (() => {
       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(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.
@@ -10484,8 +10546,8 @@ var dataStructureTyped = (() => {
       return inserted;
     }
     /**
-     * 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.
@@ -10498,7 +10560,7 @@ var dataStructureTyped = (() => {
      * 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;
@@ -10534,8 +10596,8 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * 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.
@@ -10609,8 +10671,8 @@ var dataStructureTyped = (() => {
       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.
@@ -10619,6 +10681,22 @@ 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.