min-heap-typed 1.50.1 → 1.50.3

package/dist/data-structures/queue/deque.js

@@ -11,14 +11,25 @@ const utils_1 = require("../../utils");
  * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
  */
 class Deque extends base_1.IterableElementBase {
+    /**
+     * The constructor initializes a Deque object with an optional iterable of elements and options.
+     * @param elements - An iterable object (such as an array or a Set) that contains the initial
+     * elements to be added to the deque. It can also be an object with a `length` or `size` property
+     * that represents the number of elements in the iterable object. If no elements are provided, an
+     * empty deque
+     * @param {DequeOptions} [options] - The `options` parameter is an optional object that can contain
+     * configuration options for the deque. In this code, it is used to set the `bucketSize` option,
+     * which determines the size of each bucket in the deque. If the `bucketSize` option is not provided
+     * or is not a number
+     */
     constructor(elements = [], options) {
         super();
+        this._bucketSize = 1 << 12;
         this._bucketFirst = 0;
         this._firstInBucket = 0;
         this._bucketLast = 0;
         this._lastInBucket = 0;
         this._bucketCount = 0;
-        this._bucketSize = 1 << 12;
         this._buckets = [];
         this._size = 0;
         if (options) {
@@ -50,9 +61,62 @@ class Deque extends base_1.IterableElementBase {
             this.push(element);
         }
     }
+    /**
+     * The bucketSize function returns the size of the bucket.
+     *
+     * @return The size of the bucket
+     */
+    get bucketSize() {
+        return this._bucketSize;
+    }
+    /**
+     * The function returns the value of the protected variable `_bucketFirst`.
+     * @returns The value of the `_bucketFirst` property.
+     */
+    get bucketFirst() {
+        return this._bucketFirst;
+    }
+    /**
+     * The function returns the value of the protected variable _firstInBucket.
+     * @returns The method is returning the value of the variable `_firstInBucket`, which is of type
+     * `number`.
+     */
+    get firstInBucket() {
+        return this._firstInBucket;
+    }
+    /**
+     * The function returns the value of the protected variable `_bucketLast`.
+     * @returns The value of the `_bucketLast` property, which is a number.
+     */
+    get bucketLast() {
+        return this._bucketLast;
+    }
+    /**
+     * The function returns the value of the protected variable _lastInBucket.
+     * @returns The method is returning the value of the variable `_lastInBucket`, which is of type
+     * `number`.
+     */
+    get lastInBucket() {
+        return this._lastInBucket;
+    }
+    /**
+     * The function returns the number of buckets.
+     * @returns The number of buckets.
+     */
+    get bucketCount() {
+        return this._bucketCount;
+    }
+    /**
+     * The buckets function returns the buckets property of the object.
+     * @return The buckets property
+     */
     get buckets() {
         return this._buckets;
     }
+    /**
+     * The size function returns the number of items in the stack.
+     * @return The number of values in the set
+     */
     get size() {
         return this._size;
     }
@@ -66,6 +130,10 @@ class Deque extends base_1.IterableElementBase {
             return;
         return this._buckets[this._bucketFirst][this._firstInBucket];
     }
+    /**
+     * The last function returns the last element in the queue.
+     * @return The last element in the array
+     */
     get last() {
         if (this.size === 0)
             return;
@@ -204,13 +272,27 @@ class Deque extends base_1.IterableElementBase {
         return element;
     }
     /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function checks if the size of an object is equal to zero and returns a boolean value.
+     * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
     isEmpty() {
         return this.size === 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The clear() function resets the state of the object by initializing all variables to their default
      * values.
      */
@@ -226,7 +308,7 @@ class Deque extends base_1.IterableElementBase {
     *begin() {
         let index = 0;
         while (index < this.size) {
-            yield this.getAt(index);
+            yield this.at(index);
             index++;
         }
     }
@@ -237,7 +319,7 @@ class Deque extends base_1.IterableElementBase {
     *reverseBegin() {
         let index = this.size - 1;
         while (index >= 0) {
-            yield this.getAt(index);
+            yield this.at(index);
             index--;
         }
     }
@@ -249,13 +331,13 @@ class Deque extends base_1.IterableElementBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `getAt` function retrieves an element at a specified position in an array-like data structure.
+     * The `at` function retrieves an element at a specified position in an array-like data structure.
      * @param {number} pos - The `pos` parameter represents the position of the element that you want to
      * retrieve from the data structure. It is of type `number` and should be a valid index within the
      * range of the data structure.
      * @returns The element at the specified position in the data structure is being returned.
      */
-    getAt(pos) {
+    at(pos) {
         (0, utils_1.rangeCheck)(pos, 0, this.size - 1);
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         return this._buckets[bucketIndex][indexInBucket];
@@ -313,9 +395,9 @@ class Deque extends base_1.IterableElementBase {
         else {
             const arr = [];
             for (let i = pos; i < this.size; ++i) {
-                arr.push(this.getAt(i));
+                arr.push(this.at(i));
             }
-            this.cut(pos - 1);
+            this.cut(pos - 1, true);
             for (let i = 0; i < num; ++i)
                 this.push(element);
             for (let i = 0; i < arr.length; ++i)
@@ -335,26 +417,75 @@ class Deque extends base_1.IterableElementBase {
      * updated size.
      * @param {number} pos - The `pos` parameter represents the position at which the string should be
      * cut. It is a number that indicates the index of the character where the cut should be made.
+     * @param {boolean} isCutSelf - If true, the original deque will not be cut, and return a new deque
      * @returns The method is returning the updated size of the data structure.
      */
-    cut(pos) {
-        if (pos < 0) {
-            this.clear();
-            return 0;
+    cut(pos, isCutSelf = false) {
+        if (isCutSelf) {
+            if (pos < 0) {
+                this.clear();
+                return this;
+            }
+            const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+            this._bucketLast = bucketIndex;
+            this._lastInBucket = indexInBucket;
+            this._size = pos + 1;
+            return this;
+        }
+        else {
+            const newDeque = new Deque([], { bucketSize: this._bucketSize });
+            for (let i = 0; i <= pos; i++) {
+                newDeque.push(this.at(i));
+            }
+            return newDeque;
+        }
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
+     *
+     * The `cutRest` function cuts the elements from a specified position in a deque and returns a new
+     * deque with the cut elements.
+     * @param {number} pos - The `pos` parameter represents the position from which to cut the Deque. It
+     * is a number that indicates the index of the element in the Deque where the cut should start.
+     * @param [isCutSelf=false] - isCutSelf is a boolean parameter that determines whether the original
+     * Deque should be modified or a new Deque should be created. If isCutSelf is true, the original
+     * Deque will be modified by cutting off elements starting from the specified position. If isCutSelf
+     * is false, a new De
+     * @returns The function `cutRest` returns either the modified original deque (`this`) or a new deque
+     * (`newDeque`) depending on the value of the `isCutSelf` parameter.
+     */
+    cutRest(pos, isCutSelf = false) {
+        if (isCutSelf) {
+            if (pos < 0) {
+                this.clear();
+                return this;
+            }
+            const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+            this._bucketFirst = bucketIndex;
+            this._firstInBucket = indexInBucket;
+            this._size = this._size - pos;
+            return this;
+        }
+        else {
+            const newDeque = new Deque([], { bucketSize: this._bucketSize });
+            for (let i = pos; i < this.size; i++) {
+                newDeque.push(this.at(i));
+            }
+            return newDeque;
         }
-        const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
-        this._bucketLast = bucketIndex;
-        this._lastInBucket = indexInBucket;
-        this._size = pos + 1;
-        return this.size;
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(1) or O(n)
      *
      * The `deleteAt` function removes an element at a specified position in an array-like data
      * structure.
@@ -403,14 +534,14 @@ class Deque extends base_1.IterableElementBase {
         let i = 0;
         let index = 0;
         while (i < size) {
-            const oldElement = this.getAt(i);
+            const oldElement = this.at(i);
             if (oldElement !== element) {
                 this.setAt(index, oldElement);
                 index += 1;
             }
             i += 1;
         }
-        this.cut(index - 1);
+        this.cut(index - 1, true);
         return true;
     }
     /**
@@ -454,15 +585,15 @@ class Deque extends base_1.IterableElementBase {
             return this;
         }
         let index = 1;
-        let prev = this.getAt(0);
+        let prev = this.at(0);
         for (let i = 1; i < this.size; ++i) {
-            const cur = this.getAt(i);
+            const cur = this.at(i);
             if (cur !== prev) {
                 prev = cur;
                 this.setAt(index++, cur);
             }
         }
-        this.cut(index - 1);
+        this.cut(index - 1, true);
         return this;
     }
     /**
@@ -482,7 +613,7 @@ class Deque extends base_1.IterableElementBase {
     sort(comparator) {
         const arr = [];
         for (let i = 0; i < this.size; ++i) {
-            arr.push(this.getAt(i));
+            arr.push(this.at(i));
         }
         arr.sort(comparator);
         for (let i = 0; i < this.size; ++i) {
@@ -526,30 +657,6 @@ class Deque extends base_1.IterableElementBase {
         this._bucketLast = newBuckets.length - 1;
         this._buckets = newBuckets;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `find` function iterates over the elements in a deque and returns the first element for which
-     * the callback function returns true, or undefined if no such element is found.
-     * @param callback - A function that takes three parameters: element, index, and deque. It should
-     * return a boolean value indicating whether the element satisfies a certain condition.
-     * @returns The method `find` returns the first element in the deque that satisfies the condition
-     * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
-     */
-    find(callback) {
-        for (let i = 0; i < this.size; ++i) {
-            const element = this.getAt(i);
-            if (callback(element, i, this)) {
-                return element;
-            }
-        }
-        return;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -567,7 +674,7 @@ class Deque extends base_1.IterableElementBase {
      */
     indexOf(element) {
         for (let i = 0; i < this.size; ++i) {
-            if (this.getAt(i) === element) {
+            if (this.at(i) === element) {
                 return i;
             }
         }
@@ -587,6 +694,22 @@ class Deque extends base_1.IterableElementBase {
     toArray() {
         return [...this];
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone()` function returns a new instance of the `Deque` class with the same elements and
+     * bucket size as the original instance.
+     * @returns The `clone()` method is returning a new instance of the `Deque` class with the same
+     * elements as the original deque (`this`) and the same bucket size.
+     */
+    clone() {
+        return new Deque([...this], { bucketSize: this.bucketSize });
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -649,8 +772,8 @@ class Deque extends base_1.IterableElementBase {
      * Space Complexity: O(n) - Due to potential resizing.
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
+     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
+     * Space Complexity: O(n) - Due to potential resizing.
      *
      * 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
@@ -660,12 +783,12 @@ class Deque extends base_1.IterableElementBase {
         return this.push(element);
     }
     /**
-     * Time Complexity: O(1) - Removes the first element.
-     * Space Complexity: O(1) - In-place operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function "pollLast" removes and returns the last element of an array.
      * @returns The last element of the array is being returned.
@@ -674,8 +797,13 @@ class Deque extends base_1.IterableElementBase {
         return this.pop();
     }
     /**
-     * Time Complexity: O(1).
-     * Space Complexity: O(n) - Due to potential resizing.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * 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
@@ -685,8 +813,13 @@ class Deque extends base_1.IterableElementBase {
         return this.unshift(element);
     }
     /**
-     * Time Complexity: O(1) - Removes the first element.
-     * Space Complexity: O(1) - In-place operation.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The function "pollFirst" removes and returns the first element of an array.
      * @returns The method `pollFirst()` is returning the first element of the array after removing it
@@ -696,6 +829,11 @@ class Deque extends base_1.IterableElementBase {
         return this.shift();
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * /
+  
+     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
@@ -704,7 +842,7 @@ class Deque extends base_1.IterableElementBase {
      */
     *_getIterator() {
         for (let i = 0; i < this.size; ++i) {
-            yield this.getAt(i);
+            yield this.at(i);
         }
     }
     /**