data-structure-typed 1.45.3 → 1.46.0

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

@@ -93,7 +93,6 @@ var dataStructureTyped = (() => {
     AbstractEdge: () => AbstractEdge,
     AbstractGraph: () => AbstractGraph,
     AbstractVertex: () => AbstractVertex,
-    ArrayDeque: () => ArrayDeque,
     BST: () => BST,
     BSTNode: () => BSTNode,
     BinaryIndexedTree: () => BinaryIndexedTree,
@@ -104,6 +103,7 @@ var dataStructureTyped = (() => {
     CoordinateMap: () => CoordinateMap,
     CoordinateSet: () => CoordinateSet,
     Deque: () => Deque,
+    DequeIterator: () => DequeIterator,
     DirectedEdge: () => DirectedEdge,
     DirectedGraph: () => DirectedGraph,
     DirectedVertex: () => DirectedVertex,
@@ -156,6 +156,7 @@ var dataStructureTyped = (() => {
     UndirectedVertex: () => UndirectedVertex,
     Vector2D: () => Vector2D,
     arrayRemove: () => arrayRemove,
+    calcMinUnitsRequired: () => calcMinUnitsRequired,
     getMSB: () => getMSB,
     isObjOrFunc: () => isObjOrFunc,
     isThunk: () => isThunk,
@@ -565,6 +566,7 @@ var dataStructureTyped = (() => {
     const inputType = typeof input;
     return inputType === "object" && input !== null || inputType === "function";
   };
+  var calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
 
   // src/types/data-structures/binary-tree/binary-tree.ts
   var IterationType = /* @__PURE__ */ ((IterationType3) => {
@@ -590,13 +592,6 @@ var dataStructureTyped = (() => {
     return RBTNColor2;
   })(RBTNColor || {});
 
-  // src/types/data-structures/hash/hash-map.ts
-  var IterateDirection = /* @__PURE__ */ ((IterateDirection2) => {
-    IterateDirection2[IterateDirection2["DEFAULT"] = 0] = "DEFAULT";
-    IterateDirection2[IterateDirection2["REVERSE"] = 1] = "REVERSE";
-    return IterateDirection2;
-  })(IterateDirection || {});
-
   // src/types/helpers.ts
   var CP = /* @__PURE__ */ ((CP2) => {
     CP2["lt"] = "lt";
@@ -604,9 +599,14 @@ var dataStructureTyped = (() => {
     CP2["gt"] = "gt";
     return CP2;
   })(CP || {});
+  var IterateDirection = /* @__PURE__ */ ((IterateDirection2) => {
+    IterateDirection2[IterateDirection2["DEFAULT"] = 0] = "DEFAULT";
+    IterateDirection2[IterateDirection2["REVERSE"] = 1] = "REVERSE";
+    return IterateDirection2;
+  })(IterateDirection || {});
 
   // src/data-structures/hash/hash-map.ts
-  var HashMapIterator = class {
+  var HashMapIterator = class _HashMapIterator {
     /**
      * This is a constructor function for a linked list iterator in a HashMap data structure.
      * @param node - The `node` parameter is a reference to a `HashMapLinkedNode` object. This object
@@ -704,15 +704,18 @@ var dataStructureTyped = (() => {
     next() {
       return this;
     }
+    clone() {
+      return new _HashMapIterator(this._node, this._sentinel, this.hashMap, this.iterateDirection);
+    }
   };
   var HashMap = class {
     /**
      * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
-     * @param hashMap - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
+     * @param {Iterable<[K, V]>} elements - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
      * V]>`. It is an array of key-value pairs, where each pair is represented as an array `[K, V]`. The
      * `K` represents the type of the key and `V` represents the
      */
-    constructor(hashMap = []) {
+    constructor(elements = []) {
       __publicField(this, "OBJ_KEY_INDEX", Symbol("OBJ_KEY_INDEX"));
       __publicField(this, "_nodes", []);
       __publicField(this, "_orgMap", {});
@@ -723,9 +726,9 @@ var dataStructureTyped = (() => {
       Object.setPrototypeOf(this._orgMap, null);
       this._sentinel = {};
       this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-      hashMap.forEach((el) => {
+      for (const el of elements) {
         this.set(el[0], el[1]);
-      });
+      }
     }
     get size() {
       return this._size;
@@ -781,7 +784,7 @@ var dataStructureTyped = (() => {
      * @returns The front element of the data structure, represented as a tuple with a key (K) and a
      * value (V).
      */
-    get front() {
+    get first() {
       if (this._size === 0)
         return;
       return [this._head.key, this._head.value];
@@ -794,7 +797,7 @@ var dataStructureTyped = (() => {
      * @returns The method is returning an array containing the key-value pair of the tail element in the
      * data structure.
      */
-    get back() {
+    get last() {
       if (this._size === 0)
         return;
       return [this._tail.key, this._tail.value];
@@ -3158,7 +3161,525 @@ var dataStructureTyped = (() => {
   };
 
   // src/data-structures/queue/deque.ts
-  var Deque = class extends DoublyLinkedList {
+  var DequeIterator = class _DequeIterator {
+    constructor(index, deque, iterateDirection = 0 /* DEFAULT */) {
+      __publicField(this, "iterateDirection");
+      __publicField(this, "index");
+      __publicField(this, "deque");
+      this.index = index;
+      this.iterateDirection = iterateDirection;
+      if (this.iterateDirection === 0 /* DEFAULT */) {
+        this.prev = function() {
+          if (this.index === 0) {
+            throwRangeError();
+          }
+          this.index -= 1;
+          return this;
+        };
+        this.next = function() {
+          if (this.index === this.deque.size) {
+            throwRangeError();
+          }
+          this.index += 1;
+          return this;
+        };
+      } else {
+        this.prev = function() {
+          if (this.index === this.deque.size - 1) {
+            throwRangeError();
+          }
+          this.index += 1;
+          return this;
+        };
+        this.next = function() {
+          if (this.index === -1) {
+            throwRangeError();
+          }
+          this.index -= 1;
+          return this;
+        };
+      }
+      this.deque = deque;
+    }
+    get current() {
+      return this.deque.getAt(this.index);
+    }
+    set current(newElement) {
+      this.deque.setAt(this.index, newElement);
+    }
+    isAccessible() {
+      return this.index !== this.deque.size;
+    }
+    prev() {
+      return this;
+    }
+    next() {
+      return this;
+    }
+    clone() {
+      return new _DequeIterator(this.index, this.deque, this.iterateDirection);
+    }
+  };
+  var Deque = class _Deque {
+    constructor(elements = [], bucketSize = 1 << 12) {
+      __publicField(this, "_bucketFirst", 0);
+      __publicField(this, "_firstInBucket", 0);
+      __publicField(this, "_bucketLast", 0);
+      __publicField(this, "_lastInBucket", 0);
+      __publicField(this, "_bucketCount", 0);
+      __publicField(this, "_bucketSize");
+      __publicField(this, "_buckets", []);
+      __publicField(this, "_size", 0);
+      let _size;
+      if ("length" in elements) {
+        _size = elements.length;
+      } else {
+        _size = elements.size;
+      }
+      this._bucketSize = bucketSize;
+      this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;
+      for (let i = 0; i < this._bucketCount; ++i) {
+        this._buckets.push(new Array(this._bucketSize));
+      }
+      const needBucketNum = calcMinUnitsRequired(_size, this._bucketSize);
+      this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
+      this._firstInBucket = this._lastInBucket = this._bucketSize - _size % this._bucketSize >> 1;
+      for (const element of elements) {
+        this.push(element);
+      }
+    }
+    get buckets() {
+      return this._buckets;
+    }
+    get size() {
+      return this._size;
+    }
+    get first() {
+      if (this.size === 0)
+        return;
+      return this._buckets[this._bucketFirst][this._firstInBucket];
+    }
+    get last() {
+      if (this.size === 0)
+        return;
+      return this._buckets[this._bucketLast][this._lastInBucket];
+    }
+    /**
+     * Time Complexity: Amortized O(1) - Generally constant time, but resizing when the deque is full leads to O(n).
+     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
+     */
+    empty() {
+      return this._size === 0;
+    }
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     */
+    isEmpty() {
+      return this.size === 0;
+    }
+    /**
+     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
+     * Space Complexity: O(n) - Due to potential resizing.
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
+     *
+     * The addLast function adds an element to the end of an array.
+     * @param {E} element - The element parameter represents the element that you want to add to the end of the
+     * data structure.
+     */
+    addLast(element) {
+      this.push(element);
+    }
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     */
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     *
+     * The function "popLast" removes and returns the last element of an array.
+     * @returns The last element of the array is being returned.
+     */
+    popLast() {
+      return this.pop();
+    }
+    /**
+     * Time Complexity: O(1).
+     * Space Complexity: O(n) - Due to potential resizing.
+     *
+     * The "addFirst" function adds an element to the beginning of an array.
+     * @param {E} element - The parameter "element" represents the element that you want to add to the
+     * beginning of the data structure.
+     */
+    addFirst(element) {
+      this.unshift(element);
+    }
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     *
+     * The function "popFirst" removes and returns the first element of an array.
+     * @returns The method `popFirst()` is returning the first element of the array after removing it
+     * from the beginning. If the array is empty, it will return `undefined`.
+     */
+    popFirst() {
+      return this.shift();
+    }
+    clear() {
+      this._buckets = [new Array(this._bucketSize)];
+      this._bucketCount = 1;
+      this._bucketFirst = this._bucketLast = this._size = 0;
+      this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+    }
+    begin() {
+      return new DequeIterator(0, this);
+    }
+    end() {
+      return new DequeIterator(this.size, this);
+    }
+    reverseBegin() {
+      return new DequeIterator(this.size - 1, this, 1 /* REVERSE */);
+    }
+    reverseEnd() {
+      return new DequeIterator(-1, this, 1 /* REVERSE */);
+    }
+    push(element) {
+      if (this.size) {
+        if (this._lastInBucket < this._bucketSize - 1) {
+          this._lastInBucket += 1;
+        } else if (this._bucketLast < this._bucketCount - 1) {
+          this._bucketLast += 1;
+          this._lastInBucket = 0;
+        } else {
+          this._bucketLast = 0;
+          this._lastInBucket = 0;
+        }
+        if (this._bucketLast === this._bucketFirst && this._lastInBucket === this._firstInBucket)
+          this._reallocate();
+      }
+      this._size += 1;
+      this._buckets[this._bucketLast][this._lastInBucket] = element;
+      return this.size;
+    }
+    pop() {
+      if (this.size === 0)
+        return;
+      const element = this._buckets[this._bucketLast][this._lastInBucket];
+      if (this.size !== 1) {
+        if (this._lastInBucket > 0) {
+          this._lastInBucket -= 1;
+        } else if (this._bucketLast > 0) {
+          this._bucketLast -= 1;
+          this._lastInBucket = this._bucketSize - 1;
+        } else {
+          this._bucketLast = this._bucketCount - 1;
+          this._lastInBucket = this._bucketSize - 1;
+        }
+      }
+      this._size -= 1;
+      return element;
+    }
+    unshift(element) {
+      if (this.size) {
+        if (this._firstInBucket > 0) {
+          this._firstInBucket -= 1;
+        } else if (this._bucketFirst > 0) {
+          this._bucketFirst -= 1;
+          this._firstInBucket = this._bucketSize - 1;
+        } else {
+          this._bucketFirst = this._bucketCount - 1;
+          this._firstInBucket = this._bucketSize - 1;
+        }
+        if (this._bucketFirst === this._bucketLast && this._firstInBucket === this._lastInBucket)
+          this._reallocate();
+      }
+      this._size += 1;
+      this._buckets[this._bucketFirst][this._firstInBucket] = element;
+      return this.size;
+    }
+    shift() {
+      if (this.size === 0)
+        return;
+      const element = this._buckets[this._bucketFirst][this._firstInBucket];
+      if (this.size !== 1) {
+        if (this._firstInBucket < this._bucketSize - 1) {
+          this._firstInBucket += 1;
+        } else if (this._bucketFirst < this._bucketCount - 1) {
+          this._bucketFirst += 1;
+          this._firstInBucket = 0;
+        } else {
+          this._bucketFirst = 0;
+          this._firstInBucket = 0;
+        }
+      }
+      this._size -= 1;
+      return element;
+    }
+    getAt(pos) {
+      rangeCheck(pos, 0, this.size - 1);
+      const {
+        bucketIndex,
+        indexInBucket
+      } = this._getBucketAndPosition(pos);
+      return this._buckets[bucketIndex][indexInBucket];
+    }
+    setAt(pos, element) {
+      rangeCheck(pos, 0, this.size - 1);
+      const {
+        bucketIndex,
+        indexInBucket
+      } = this._getBucketAndPosition(pos);
+      this._buckets[bucketIndex][indexInBucket] = element;
+    }
+    insertAt(pos, element, num = 1) {
+      const length = this.size;
+      rangeCheck(pos, 0, length);
+      if (pos === 0) {
+        while (num--)
+          this.unshift(element);
+      } else if (pos === this.size) {
+        while (num--)
+          this.push(element);
+      } else {
+        const arr = [];
+        for (let i = pos; i < this.size; ++i) {
+          arr.push(this.getAt(i));
+        }
+        this.cut(pos - 1);
+        for (let i = 0; i < num; ++i)
+          this.push(element);
+        for (let i = 0; i < arr.length; ++i)
+          this.push(arr[i]);
+      }
+      return this.size;
+    }
+    cut(pos) {
+      if (pos < 0) {
+        this.clear();
+        return 0;
+      }
+      const {
+        bucketIndex,
+        indexInBucket
+      } = this._getBucketAndPosition(pos);
+      this._bucketLast = bucketIndex;
+      this._lastInBucket = indexInBucket;
+      this._size = pos + 1;
+      return this.size;
+    }
+    deleteAt(pos) {
+      rangeCheck(pos, 0, this.size - 1);
+      if (pos === 0)
+        this.shift();
+      else if (pos === this.size - 1)
+        this.pop();
+      else {
+        const length = this.size - 1;
+        let {
+          bucketIndex: curBucket,
+          indexInBucket: curPointer
+        } = this._getBucketAndPosition(pos);
+        for (let i = pos; i < length; ++i) {
+          const {
+            bucketIndex: nextBucket,
+            indexInBucket: nextPointer
+          } = this._getBucketAndPosition(pos + 1);
+          this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];
+          curBucket = nextBucket;
+          curPointer = nextPointer;
+        }
+        this.pop();
+      }
+      return this.size;
+    }
+    delete(element) {
+      const size = this.size;
+      if (size === 0)
+        return 0;
+      let i = 0;
+      let index = 0;
+      while (i < size) {
+        const oldElement = this.getAt(i);
+        if (oldElement !== element) {
+          this.setAt(index, oldElement);
+          index += 1;
+        }
+        i += 1;
+      }
+      this.cut(index - 1);
+      return this.size;
+    }
+    deleteByIterator(iter) {
+      const index = iter.index;
+      this.deleteAt(index);
+      iter = iter.next();
+      return iter;
+    }
+    findIterator(element) {
+      for (let i = 0; i < this.size; ++i) {
+        if (this.getAt(i) === element) {
+          return new DequeIterator(i, this);
+        }
+      }
+      return this.end();
+    }
+    reverse() {
+      this._buckets.reverse().forEach(function(bucket) {
+        bucket.reverse();
+      });
+      const { _bucketFirst, _bucketLast, _firstInBucket, _lastInBucket } = this;
+      this._bucketFirst = this._bucketCount - _bucketLast - 1;
+      this._bucketLast = this._bucketCount - _bucketFirst - 1;
+      this._firstInBucket = this._bucketSize - _lastInBucket - 1;
+      this._lastInBucket = this._bucketSize - _firstInBucket - 1;
+      return this;
+    }
+    unique() {
+      if (this.size <= 1) {
+        return this.size;
+      }
+      let index = 1;
+      let prev = this.getAt(0);
+      for (let i = 1; i < this.size; ++i) {
+        const cur = this.getAt(i);
+        if (cur !== prev) {
+          prev = cur;
+          this.setAt(index++, cur);
+        }
+      }
+      this.cut(index - 1);
+      return this.size;
+    }
+    sort(comparator) {
+      const arr = [];
+      for (let i = 0; i < this.size; ++i) {
+        arr.push(this.getAt(i));
+      }
+      arr.sort(comparator);
+      for (let i = 0; i < this.size; ++i) {
+        this.setAt(i, arr[i]);
+      }
+      return this;
+    }
+    shrinkToFit() {
+      if (this.size === 0)
+        return;
+      const newBuckets = [];
+      if (this._bucketFirst === this._bucketLast)
+        return;
+      else if (this._bucketFirst < this._bucketLast) {
+        for (let i = this._bucketFirst; i <= this._bucketLast; ++i) {
+          newBuckets.push(this._buckets[i]);
+        }
+      } else {
+        for (let i = this._bucketFirst; i < this._bucketCount; ++i) {
+          newBuckets.push(this._buckets[i]);
+        }
+        for (let i = 0; i <= this._bucketLast; ++i) {
+          newBuckets.push(this._buckets[i]);
+        }
+      }
+      this._bucketFirst = 0;
+      this._bucketLast = newBuckets.length - 1;
+      this._buckets = newBuckets;
+    }
+    forEach(callback) {
+      for (let i = 0; i < this.size; ++i) {
+        callback(this.getAt(i), i, this);
+      }
+    }
+    find(callback) {
+      for (let i = 0; i < this.size; ++i) {
+        const element = this.getAt(i);
+        if (callback(element, i, this)) {
+          return element;
+        }
+      }
+      return void 0;
+    }
+    toArray() {
+      const arr = [];
+      for (let i = 0; i < this.size; ++i) {
+        arr.push(this.getAt(i));
+      }
+      return arr;
+    }
+    map(callback) {
+      const newDeque = new _Deque([], this._bucketSize);
+      for (let i = 0; i < this.size; ++i) {
+        newDeque.push(callback(this.getAt(i), i, this));
+      }
+      return newDeque;
+    }
+    filter(predicate) {
+      const newDeque = new _Deque([], this._bucketSize);
+      for (let i = 0; i < this.size; ++i) {
+        const element = this.getAt(i);
+        if (predicate(element, i, this)) {
+          newDeque.push(element);
+        }
+      }
+      return newDeque;
+    }
+    reduce(callback, initialValue) {
+      let accumulator = initialValue;
+      for (let i = 0; i < this.size; ++i) {
+        accumulator = callback(accumulator, this.getAt(i), i, this);
+      }
+      return accumulator;
+    }
+    indexOf(element) {
+      for (let i = 0; i < this.size; ++i) {
+        if (this.getAt(i) === element) {
+          return i;
+        }
+      }
+      return -1;
+    }
+    *[Symbol.iterator]() {
+      for (let i = 0; i < this.size; ++i) {
+        yield this.getAt(i);
+      }
+    }
+    _reallocate(needBucketNum) {
+      const newBuckets = [];
+      const addBucketNum = needBucketNum || this._bucketCount >> 1 || 1;
+      for (let i = 0; i < addBucketNum; ++i) {
+        newBuckets[i] = new Array(this._bucketSize);
+      }
+      for (let i = this._bucketFirst; i < this._bucketCount; ++i) {
+        newBuckets[newBuckets.length] = this._buckets[i];
+      }
+      for (let i = 0; i < this._bucketLast; ++i) {
+        newBuckets[newBuckets.length] = this._buckets[i];
+      }
+      newBuckets[newBuckets.length] = [...this._buckets[this._bucketLast]];
+      this._bucketFirst = addBucketNum;
+      this._bucketLast = newBuckets.length - 1;
+      for (let i = 0; i < addBucketNum; ++i) {
+        newBuckets[newBuckets.length] = new Array(this._bucketSize);
+      }
+      this._buckets = newBuckets;
+      this._bucketCount = newBuckets.length;
+    }
+    _getBucketAndPosition(pos) {
+      let bucketIndex;
+      let indexInBucket;
+      const overallIndex = this._firstInBucket + pos;
+      bucketIndex = this._bucketFirst + Math.floor(overallIndex / this._bucketSize);
+      if (bucketIndex >= this._bucketCount) {
+        bucketIndex -= this._bucketCount;
+      }
+      indexInBucket = (overallIndex + 1) % this._bucketSize - 1;
+      if (indexInBucket < 0) {
+        indexInBucket = this._bucketSize - 1;
+      }
+      return { bucketIndex, indexInBucket };
+    }
   };
   var ObjectDeque = class {
     constructor(capacity) {
@@ -3193,11 +3714,11 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The "addFirst" function adds a value to the beginning of an array-like data structure.
-     * @param {E} value - The `value` parameter represents the value that you want to add to the beginning of the data
+     * The "addFirst" function adds an element to the beginning of an array-like data structure.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the beginning of the data
      * structure.
      */
-    addFirst(value) {
+    addFirst(element) {
       if (this.size === 0) {
         const mid = Math.floor(this.capacity / 2);
         this._first = mid;
@@ -3205,7 +3726,7 @@ var dataStructureTyped = (() => {
       } else {
         this._first--;
       }
-      this.nodes[this.first] = value;
+      this.nodes[this.first] = element;
       this._size++;
     }
     /**
@@ -3216,10 +3737,10 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The addLast function adds a value to the end of an array-like data structure.
-     * @param {E} value - The `value` parameter represents the value that you want to add to the end of the data structure.
+     * The addLast function adds an element to the end of an array-like data structure.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the end of the data structure.
      */
-    addLast(value) {
+    addLast(element) {
       if (this.size === 0) {
         const mid = Math.floor(this.capacity / 2);
         this._first = mid;
@@ -3227,7 +3748,7 @@ var dataStructureTyped = (() => {
       } else {
         this._last++;
       }
-      this.nodes[this.last] = value;
+      this.nodes[this.last] = element;
       this._size++;
     }
     /**
@@ -3239,16 +3760,16 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The function `popFirst()` removes and returns the first element in a data structure.
-     * @returns The value of the first element in the data structure.
+     * @returns The element of the first element in the data structure.
      */
     popFirst() {
       if (!this.size)
         return;
-      const value = this.getFirst();
+      const element = this.getFirst();
       delete this.nodes[this.first];
       this._first++;
       this._size--;
-      return value;
+      return element;
     }
     /**
      * Time Complexity: O(1)
@@ -3274,16 +3795,16 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      *
      * The `popLast()` function removes and returns the last element in a data structure.
-     * @returns The value that was removed from the data structure.
+     * @returns The element that was removed from the data structure.
      */
     popLast() {
       if (!this.size)
         return;
-      const value = this.getLast();
+      const element = this.getLast();
       delete this.nodes[this.last];
       this._last--;
       this._size--;
-      return value;
+      return element;
     }
     /**
      * Time Complexity: O(1)
@@ -3312,217 +3833,33 @@ var dataStructureTyped = (() => {
      * @param {number} index - The index parameter is a number that represents the position of the element you want to
      * retrieve from the array.
      * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
-     * index, `null` is returned.
+     * index, `undefined` is returned.
      */
     get(index) {
-      return this.nodes[this.first + index] || null;
+      return this.nodes[this.first + index] || void 0;
     }
     /**
      * The function checks if the size of a data structure is less than or equal to zero.
-     * @returns The method is returning a boolean value indicating whether the size of the object is less than or equal to 0.
+     * @returns The method is returning a boolean element indicating whether the size of the object is less than or equal to 0.
      */
     isEmpty() {
       return this.size <= 0;
     }
   };
-  var ArrayDeque = class {
-    constructor() {
-      __publicField(this, "_nodes", []);
-    }
-    get nodes() {
-      return this._nodes;
-    }
-    get size() {
-      return this.nodes.length;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function "addLast" adds a value to the end of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the end of the array.
-     * @returns The return value is the new length of the array after the value has been added.
-     */
-    addLast(value) {
-      return this.nodes.push(value);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
-     * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
-     */
-    popLast() {
-      var _a;
-      return (_a = this.nodes.pop()) != null ? _a : null;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
-     * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
-     * empty.
-     */
-    popFirst() {
-      var _a;
-      return (_a = this.nodes.shift()) != null ? _a : null;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function "addFirst" adds a value to the beginning of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the beginning of the array.
-     * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
-     * `value` at the beginning.
-     */
-    addFirst(value) {
-      return this.nodes.unshift(value);
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getFirst` function returns the first element of an array or null if the array is empty.
-     * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
-     * empty, it will return `null`.
-     */
-    getFirst() {
-      var _a;
-      return (_a = this.nodes[0]) != null ? _a : null;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `getLast` function returns the last element of an array or null if the array is empty.
-     * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
-     */
-    getLast() {
-      var _a;
-      return (_a = this.nodes[this.nodes.length - 1]) != null ? _a : null;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The get function returns the element at the specified index in an array, or null if the index is out of bounds.
-     * @param {number} index - The index parameter is a number that represents the position of the element you want to
-     * retrieve from the array.
-     * @returns The method is returning the element at the specified index in the `_nodes` array. If the element exists, it
-     * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
-     */
-    get(index) {
-      var _a;
-      return (_a = this.nodes[index]) != null ? _a : null;
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The set function assigns a value to a specific index in an array.
-     * @param {number} index - The index parameter is a number that represents the position of the element in the array
-     * that you want to set a new value for.
-     * @param {E} value - The value parameter represents the new value that you want to set at the specified index in the
-     * _nodes array.
-     * @returns The value that is being set at the specified index in the `_nodes` array.
-     */
-    set(index, value) {
-      return this.nodes[index] = value;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The insert function adds a value at a specified index in an array.
-     * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
-     * array. It is a number that represents the index of the array where the value should be inserted. The index starts
-     * from 0, so the first element of the array has an index of 0, the second element has
-     * @param {E} value - The value parameter represents the value that you want to insert into the array at the specified
-     * index.
-     * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
-     * are being removed, an empty array will be returned.
-     */
-    insert(index, value) {
-      return this.nodes.splice(index, 0, value);
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The delete function removes an element from an array at a specified index.
-     * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
-     * is a number that represents the index of the element to be removed.
-     * @returns The method is returning an array containing the removed element.
-     */
-    delete(index) {
-      return this.nodes.splice(index, 1);
-    }
-    /**
-     * The function checks if an array called "_nodes" is empty.
-     * @returns The method `isEmpty()` is returning a boolean value. It returns `true` if the length of the `_nodes` array
-     * is 0, indicating that the array is empty. Otherwise, it returns `false`.
-     */
-    isEmpty() {
-      return this.nodes.length === 0;
-    }
-  };
 
   // src/data-structures/heap/heap.ts
   var Heap = class _Heap {
     constructor(options) {
-      __publicField(this, "_nodes", []);
+      __publicField(this, "_elements", []);
       __publicField(this, "_comparator");
       this._comparator = options.comparator;
-      if (options.nodes && options.nodes.length > 0) {
-        this._nodes = options.nodes;
+      if (options.elements && options.elements.length > 0) {
+        this._elements = options.elements;
         this.fix();
       }
     }
-    get nodes() {
-      return this._nodes;
+    get elements() {
+      return this._elements;
     }
     get comparator() {
       return this._comparator;
@@ -3531,7 +3868,7 @@ var dataStructureTyped = (() => {
      * Get the size (number of elements) of the heap.
      */
     get size() {
-      return this.nodes.length;
+      return this.elements.length;
     }
     /**
      * Get the last element in the heap, which is not necessarily a leaf node.
@@ -3539,10 +3876,10 @@ var dataStructureTyped = (() => {
      */
     get leaf() {
       var _a;
-      return (_a = this.nodes[this.size - 1]) != null ? _a : void 0;
+      return (_a = this.elements[this.size - 1]) != null ? _a : void 0;
     }
     /**
-     * Static method that creates a binary heap from an array of nodes and a comparison function.
+     * Static method that creates a binary heap from an array of elements and a comparison function.
      * @returns A new Heap instance.
      * @param options
      */
@@ -3550,11 +3887,11 @@ var dataStructureTyped = (() => {
       return new _Heap(options);
     }
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Insert an element into the heap and maintain the heap properties.
@@ -3564,50 +3901,49 @@ var dataStructureTyped = (() => {
       return this.push(element);
     }
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Insert an element into the heap and maintain the heap properties.
      * @param element - The element to be inserted.
      */
     push(element) {
-      this.nodes.push(element);
-      this.bubbleUp(this.nodes.length - 1);
+      this._elements.push(element);
+      this._bubbleUp(this.elements.length - 1);
       return this;
     }
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
      * @returns The top element or undefined if the heap is empty.
      */
     poll() {
-      if (this.nodes.length === 0) {
-        return void 0;
-      }
-      if (this.nodes.length === 1) {
-        return this.nodes.pop();
+      if (this.elements.length === 0)
+        return;
+      const value = this.elements[0];
+      const last = this.elements.pop();
+      if (this.elements.length) {
+        this.elements[0] = last;
+        this._sinkDown(0, this.elements.length >> 1);
       }
-      const topValue = this.nodes[0];
-      this.nodes[0] = this.nodes.pop();
-      this.sinkDown(0);
-      return topValue;
+      return value;
     }
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -3621,10 +3957,7 @@ var dataStructureTyped = (() => {
      * @returns The top element or undefined if the heap is empty.
      */
     peek() {
-      if (this.nodes.length === 0) {
-        return void 0;
-      }
-      return this.nodes[0];
+      return this.elements[0];
     }
     /**
      * Check if the heap is empty.
@@ -3634,32 +3967,32 @@ var dataStructureTyped = (() => {
       return this.size === 0;
     }
     /**
-     * Reset the nodes of the heap. Make the nodes empty.
+     * Reset the elements of the heap. Make the elements empty.
      */
     clear() {
-      this._nodes = [];
+      this._elements = [];
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the nodes array.
+     * Time Complexity: O(n), where n is the number of elements in the elements array.
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the nodes array.
+     * Time Complexity: O(n), where n is the number of elements in the elements array.
      * Space Complexity: O(n)
      *
-     * Clear and add nodes of the heap
-     * @param nodes
+     * Clear and add elements of the heap
+     * @param elements
      */
-    refill(nodes) {
-      this._nodes = nodes;
+    refill(elements) {
+      this._elements = elements;
       this.fix();
     }
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Time Complexity: O(n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Time Complexity: O(n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Use a comparison function to check whether a binary heap contains a specific element.
@@ -3667,14 +4000,44 @@ var dataStructureTyped = (() => {
      * @returns Returns true if the specified element is contained; otherwise, returns false.
      */
     has(element) {
-      return this.nodes.includes(element);
+      return this.elements.includes(element);
     }
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Space Complexity: O(1)
+     *
+     * The `delete` function removes an element from an array-like data structure, maintaining the order
+     * and structure of the remaining elements.
+     * @param {E} element - The `element` parameter represents the element that you want to delete from
+     * the array `this.elements`.
+     * @returns The `delete` function is returning a boolean value. It returns `true` if the element was
+     * successfully deleted from the array, and `false` if the element was not found in the array.
+     */
+    delete(element) {
+      const index = this.elements.indexOf(element);
+      if (index < 0)
+        return false;
+      if (index === 0) {
+        this.pop();
+      } else if (index === this.elements.length - 1) {
+        this.elements.pop();
+      } else {
+        this.elements.splice(index, 1, this.elements.pop());
+        this._bubbleUp(index);
+        this._sinkDown(index, this.elements.length >> 1);
+      }
+      return true;
+    }
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the heap.
      * Space Complexity: O(h), where h is the height of the heap.
      */
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Time Complexity: O(n), where n is the number of elements in the heap.
      * Space Complexity: O(h), where h is the height of the heap.
      *
      * Depth-first search (DFS) method, different traversal orders can be selected。
@@ -3687,16 +4050,16 @@ var dataStructureTyped = (() => {
         if (index < this.size) {
           if (order === "in") {
             dfsHelper(2 * index + 1);
-            result.push(this.nodes[index]);
+            result.push(this.elements[index]);
             dfsHelper(2 * index + 2);
           } else if (order === "pre") {
-            result.push(this.nodes[index]);
+            result.push(this.elements[index]);
             dfsHelper(2 * index + 1);
             dfsHelper(2 * index + 2);
           } else if (order === "post") {
             dfsHelper(2 * index + 1);
             dfsHelper(2 * index + 2);
-            result.push(this.nodes[index]);
+            result.push(this.elements[index]);
           }
         }
       };
@@ -3715,14 +4078,7 @@ var dataStructureTyped = (() => {
      * @returns An array containing the elements of the heap.
      */
     toArray() {
-      return [...this.nodes];
-    }
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    getNodes() {
-      return this.nodes;
+      return [...this.elements];
     }
     /**
      * Time Complexity: O(n)
@@ -3737,7 +4093,7 @@ var dataStructureTyped = (() => {
      */
     clone() {
       const clonedHeap = new _Heap({ comparator: this.comparator });
-      clonedHeap._nodes = [...this.nodes];
+      clonedHeap._elements = [...this.elements];
       return clonedHeap;
     }
     /**
@@ -3766,23 +4122,14 @@ var dataStructureTyped = (() => {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n)
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * Float operation to maintain heap properties after adding an element.
-     * @param index - The index of the newly added element.
+     * Fix the entire heap to maintain heap properties.
      */
-    bubbleUp(index) {
-      const item = this.nodes[index];
-      while (index > 0) {
-        const parent = index - 1 >> 1;
-        const parentItem = this.nodes[parent];
-        if (this.comparator(parentItem, item) <= 0)
-          break;
-        this.nodes[index] = parentItem;
-        index = parent;
-      }
-      this.nodes[index] = item;
+    fix() {
+      for (let i = Math.floor(this.size / 2); i >= 0; i--)
+        this._sinkDown(i, this.elements.length >> 1);
     }
     /**
      * Time Complexity: O(log n)
@@ -3792,40 +4139,49 @@ var dataStructureTyped = (() => {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Sinking operation to maintain heap properties after removing the top element.
-     * @param index - The index from which to start sinking.
+     * Float operation to maintain heap properties after adding an element.
+     * @param index - The index of the newly added element.
      */
-    sinkDown(index) {
-      const leftChildIndex = index << 1 | 1;
-      const rightChildIndex = leftChildIndex + 1;
-      const length = this.nodes.length;
-      let targetIndex = index;
-      if (leftChildIndex < length && this.comparator(this.nodes[leftChildIndex], this.nodes[targetIndex]) < 0) {
-        targetIndex = leftChildIndex;
-      }
-      if (rightChildIndex < length && this.comparator(this.nodes[rightChildIndex], this.nodes[targetIndex]) < 0) {
-        targetIndex = rightChildIndex;
-      }
-      if (targetIndex !== index) {
-        const temp = this.nodes[index];
-        this.nodes[index] = this.nodes[targetIndex];
-        this.nodes[targetIndex] = temp;
-        this.sinkDown(targetIndex);
+    _bubbleUp(index) {
+      const element = this.elements[index];
+      while (index > 0) {
+        const parent = index - 1 >> 1;
+        const parentItem = this.elements[parent];
+        if (this._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(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Fix the entire heap to maintain heap properties.
-     */
-    fix() {
-      for (let i = Math.floor(this.size / 2); i >= 0; i--)
-        this.sinkDown(i);
+     * Sinking operation to maintain heap properties after removing the top element.
+     * @param index - The index from which to start sinking.
+     * @param halfLength
+     */
+    _sinkDown(index, halfLength) {
+      const element = this.elements[index];
+      while (index < halfLength) {
+        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) {
+          left = right;
+          minItem = this.elements[right];
+        }
+        if (this._comparator(minItem, element) >= 0)
+          break;
+        this.elements[index] = minItem;
+        index = left;
+      }
+      this.elements[index] = element;
     }
   };
   var FibonacciHeapNode = class {
@@ -3929,22 +4285,22 @@ var dataStructureTyped = (() => {
       return this.min ? this.min.element : void 0;
     }
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the linked list.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the linked list.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
      * Get the size (number of elements) of the heap.
      * @param {FibonacciHeapNode<E>} head - The head of the linked list.
      * @protected
-     * @returns FibonacciHeapNode<E>[] - An array containing the nodes of the linked list.
+     * @returns FibonacciHeapNode<E>[] - An array containing the elements of the linked list.
      */
     consumeLinkedList(head) {
-      const nodes = [];
+      const elements = [];
       if (!head)
-        return nodes;
+        return elements;
       let node = head;
       let flag = false;
       while (true) {
@@ -3953,11 +4309,11 @@ var dataStructureTyped = (() => {
         else if (node === head)
           flag = true;
         if (node) {
-          nodes.push(node);
+          elements.push(node);
           node = node.right;
         }
       }
-      return nodes;
+      return elements;
     }
     /**
      * Time Complexity: O(1)
@@ -3977,11 +4333,11 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -3991,11 +4347,11 @@ var dataStructureTyped = (() => {
       return this.pop();
     }
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -4006,8 +4362,8 @@ var dataStructureTyped = (() => {
         return void 0;
       const z = this.min;
       if (z.child) {
-        const nodes = this.consumeLinkedList(z.child);
-        for (const node of nodes) {
+        const elements = this.consumeLinkedList(z.child);
+        for (const node of elements) {
           this.mergeWithRoot(node);
           node.parent = void 0;
         }
@@ -4138,11 +4494,11 @@ var dataStructureTyped = (() => {
       y.parent = x;
     }
     /**
-     * Time Complexity: O(n log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(n log n), where n is the number of elements in the heap.
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(n log n), where n is the number of elements in the heap.
      * Space Complexity: O(n)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -4150,9 +4506,9 @@ var dataStructureTyped = (() => {
      */
     consolidate() {
       const A = new Array(this.size);
-      const nodes = this.consumeLinkedList(this.root);
+      const elements = this.consumeLinkedList(this.root);
       let x, y, d, t;
-      for (const node of nodes) {
+      for (const node of elements) {
         x = node;
         d = x.degree;
         while (A[d]) {