queue-typed 1.54.3 → 2.0.1

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

@@ -1,16 +1,104 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deque = void 0;
-const base_1 = require("../base");
 const utils_1 = require("../../utils");
+const linear_base_1 = require("../base/linear-base");
 /**
  * 1. Operations at Both Ends: Supports adding and removing elements at both the front and back of the queue. This allows it to be used as a stack (last in, first out) and a queue (first in, first out).
  * 2. Efficient Random Access: Being based on an array, it offers fast random access capability, allowing constant time access to any element.
  * 3. Continuous Memory Allocation: Since it is based on an array, all elements are stored contiguously in memory, which can bring cache friendliness and efficient memory access.
  * 4. Efficiency: Adding and removing elements at both ends of a deque is usually very fast. However, when the dynamic array needs to expand, it may involve copying the entire array to a larger one, and this operation has a time complexity of O(n).
  * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
+ * @example
+ * // prize roulette
+ *     class PrizeRoulette {
+ *       private deque: Deque<string>;
+ *
+ *       constructor(prizes: string[]) {
+ *         // Initialize the deque with prizes
+ *         this.deque = new Deque<string>(prizes);
+ *       }
+ *
+ *       // Rotate clockwise to the right (forward)
+ *       rotateClockwise(steps: number): void {
+ *         const n = this.deque.length;
+ *         if (n === 0) return;
+ *
+ *         for (let i = 0; i < steps; i++) {
+ *           const last = this.deque.pop(); // Remove the last element
+ *           this.deque.unshift(last!); // Add it to the front
+ *         }
+ *       }
+ *
+ *       // Rotate counterclockwise to the left (backward)
+ *       rotateCounterClockwise(steps: number): void {
+ *         const n = this.deque.length;
+ *         if (n === 0) return;
+ *
+ *         for (let i = 0; i < steps; i++) {
+ *           const first = this.deque.shift(); // Remove the first element
+ *           this.deque.push(first!); // Add it to the back
+ *         }
+ *       }
+ *
+ *       // Display the current prize at the head
+ *       display() {
+ *         return this.deque.first;
+ *       }
+ *     }
+ *
+ *     // Example usage
+ *     const prizes = ['Car', 'Bike', 'Laptop', 'Phone', 'Watch', 'Headphones']; // Initialize the prize list
+ *     const roulette = new PrizeRoulette(prizes);
+ *
+ *     // Display the initial state
+ *     console.log(roulette.display()); // 'Car' // Car
+ *
+ *     // Rotate clockwise by 3 steps
+ *     roulette.rotateClockwise(3);
+ *     console.log(roulette.display()); // 'Phone' // Phone
+ *
+ *     // Rotate counterclockwise by 2 steps
+ *     roulette.rotateCounterClockwise(2);
+ *     console.log(roulette.display()); // 'Headphones'
+ * @example
+ * // sliding window
+ *     // Maximum function of sliding window
+ *     function maxSlidingWindow(nums: number[], k: number): number[] {
+ *       const n = nums.length;
+ *       if (n * k === 0) return [];
+ *
+ *       const deq = new Deque<number>();
+ *       const result: number[] = [];
+ *
+ *       for (let i = 0; i < n; i++) {
+ *         // Delete indexes in the queue that are not within the window range
+ *         if (deq.length > 0 && deq.first! === i - k) {
+ *           deq.shift();
+ *         }
+ *
+ *         // Remove all indices less than the current value from the tail of the queue
+ *         while (deq.length > 0 && nums[deq.last!] < nums[i]) {
+ *           deq.pop();
+ *         }
+ *
+ *         // Add the current index to the end of the queue
+ *         deq.push(i);
+ *
+ *         // Add the maximum value of the window to the results
+ *         if (i >= k - 1) {
+ *           result.push(nums[deq.first!]);
+ *         }
+ *       }
+ *
+ *       return result;
+ *     }
+ *
+ *     const nums = [1, 3, -1, -3, 5, 3, 6, 7];
+ *     const k = 3;
+ *     console.log(maxSlidingWindow(nums, k)); // [3, 3, 5, 5, 6, 7]
  */
-class Deque extends base_1.IterableElementBase {
+class Deque extends linear_base_1.LinearBase {
     /**
      * The constructor initializes a Deque object with optional iterable of elements and options.
      * @param elements - An iterable object (such as an array or a Set) that contains the initial
@@ -25,20 +113,17 @@ class Deque extends base_1.IterableElementBase {
     constructor(elements = [], options) {
         super(options);
         this._bucketSize = 1 << 12;
-        this._maxLen = -1;
         this._bucketFirst = 0;
         this._firstInBucket = 0;
         this._bucketLast = 0;
         this._lastInBucket = 0;
         this._bucketCount = 0;
         this._buckets = [];
-        this._size = 0;
+        this._length = 0;
         if (options) {
-            const { bucketSize, maxLen } = options;
+            const { bucketSize } = options;
             if (typeof bucketSize === 'number')
                 this._bucketSize = bucketSize;
-            if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0)
-                this._maxLen = maxLen;
         }
         let _size;
         if ('length' in elements) {
@@ -62,72 +147,29 @@ class Deque extends base_1.IterableElementBase {
         this._firstInBucket = this._lastInBucket = (this._bucketSize - (_size % this._bucketSize)) >> 1;
         this.pushMany(elements);
     }
-    /**
-     * The bucketSize function returns the size of the bucket.
-     *
-     * @return The size of the bucket
-     */
     get bucketSize() {
         return this._bucketSize;
     }
-    /**
-     * The maxLen function returns the max length of the deque.
-     *
-     * @return The max length of the deque
-     */
-    get maxLen() {
-        return this._maxLen;
-    }
-    /**
-     * 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;
+    get length() {
+        return this._length;
     }
     /**
      * The function returns the first element in a collection if it exists, otherwise it returns
@@ -135,7 +177,7 @@ class Deque extends base_1.IterableElementBase {
      * @returns The first element of the collection, of type E, is being returned.
      */
     get first() {
-        if (this._size === 0)
+        if (this._length === 0)
             return;
         return this._buckets[this._bucketFirst][this._firstInBucket];
     }
@@ -144,7 +186,7 @@ class Deque extends base_1.IterableElementBase {
      * @return The last element in the array
      */
     get last() {
-        if (this._size === 0)
+        if (this._length === 0)
             return;
         return this._buckets[this._bucketLast][this._lastInBucket];
     }
@@ -158,7 +200,7 @@ class Deque extends base_1.IterableElementBase {
      * @returns The size of the data structure after the element has been pushed.
      */
     push(element) {
-        if (this._size) {
+        if (this._length) {
             if (this._lastInBucket < this._bucketSize - 1) {
                 this._lastInBucket += 1;
             }
@@ -173,9 +215,9 @@ class Deque extends base_1.IterableElementBase {
             if (this._bucketLast === this._bucketFirst && this._lastInBucket === this._firstInBucket)
                 this._reallocate();
         }
-        this._size += 1;
+        this._length += 1;
         this._buckets[this._bucketLast][this._lastInBucket] = element;
-        if (this._maxLen > 0 && this._size > this._maxLen)
+        if (this._maxLen > 0 && this._length > this._maxLen)
             this.shift();
         return true;
     }
@@ -188,10 +230,10 @@ class Deque extends base_1.IterableElementBase {
      * @returns The element that was removed from the data structure is being returned.
      */
     pop() {
-        if (this._size === 0)
+        if (this._length === 0)
             return;
         const element = this._buckets[this._bucketLast][this._lastInBucket];
-        if (this._size !== 1) {
+        if (this._length !== 1) {
             if (this._lastInBucket > 0) {
                 this._lastInBucket -= 1;
             }
@@ -204,7 +246,7 @@ class Deque extends base_1.IterableElementBase {
                 this._lastInBucket = this._bucketSize - 1;
             }
         }
-        this._size -= 1;
+        this._length -= 1;
         return element;
     }
     /**
@@ -217,10 +259,10 @@ class Deque extends base_1.IterableElementBase {
      * returned.
      */
     shift() {
-        if (this._size === 0)
+        if (this._length === 0)
             return;
         const element = this._buckets[this._bucketFirst][this._firstInBucket];
-        if (this._size !== 1) {
+        if (this._length !== 1) {
             if (this._firstInBucket < this._bucketSize - 1) {
                 this._firstInBucket += 1;
             }
@@ -233,7 +275,7 @@ class Deque extends base_1.IterableElementBase {
                 this._firstInBucket = 0;
             }
         }
-        this._size -= 1;
+        this._length -= 1;
         return element;
     }
     /**
@@ -247,7 +289,7 @@ class Deque extends base_1.IterableElementBase {
      * @returns The size of the data structure after the element has been added.
      */
     unshift(element) {
-        if (this._size) {
+        if (this._length) {
             if (this._firstInBucket > 0) {
                 this._firstInBucket -= 1;
             }
@@ -262,9 +304,9 @@ class Deque extends base_1.IterableElementBase {
             if (this._bucketFirst === this._bucketLast && this._firstInBucket === this._lastInBucket)
                 this._reallocate();
         }
-        this._size += 1;
+        this._length += 1;
         this._buckets[this._bucketFirst][this._firstInBucket] = element;
-        if (this._maxLen > 0 && this._size > this._maxLen)
+        if (this._maxLen > 0 && this._length > this._maxLen)
             this.pop();
         return true;
     }
@@ -327,7 +369,7 @@ class Deque extends base_1.IterableElementBase {
      * @returns A boolean value indicating whether the size of the object is 0 or not.
      */
     isEmpty() {
-        return this._size === 0;
+        return this._length === 0;
     }
     /**
      * Time Complexity: O(1)
@@ -339,30 +381,9 @@ class Deque extends base_1.IterableElementBase {
     clear() {
         this._buckets = [new Array(this._bucketSize)];
         this._bucketCount = 1;
-        this._bucketFirst = this._bucketLast = this._size = 0;
+        this._bucketFirst = this._bucketLast = this._length = 0;
         this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
     }
-    /**
-     * The below function is a generator that yields elements from a collection one by one.
-     */
-    *begin() {
-        let index = 0;
-        while (index < this._size) {
-            yield this.at(index);
-            index++;
-        }
-    }
-    /**
-     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
-     * the last element.
-     */
-    *reverseBegin() {
-        let index = this._size - 1;
-        while (index >= 0) {
-            yield this.at(index);
-            index--;
-        }
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -374,7 +395,7 @@ class Deque extends base_1.IterableElementBase {
      * @returns The element at the specified position in the data structure is being returned.
      */
     at(pos) {
-        (0, utils_1.rangeCheck)(pos, 0, this._size - 1);
+        (0, utils_1.rangeCheck)(pos, 0, this._length - 1);
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         return this._buckets[bucketIndex][indexInBucket];
     }
@@ -389,7 +410,7 @@ class Deque extends base_1.IterableElementBase {
      * position in the data structure.
      */
     setAt(pos, element) {
-        (0, utils_1.rangeCheck)(pos, 0, this._size - 1);
+        (0, utils_1.rangeCheck)(pos, 0, this._length - 1);
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         this._buckets[bucketIndex][indexInBucket] = element;
         return true;
@@ -410,19 +431,19 @@ class Deque extends base_1.IterableElementBase {
      * @returns The size of the array after the insertion is being returned.
      */
     addAt(pos, element, num = 1) {
-        const length = this._size;
+        const length = this._length;
         (0, utils_1.rangeCheck)(pos, 0, length);
         if (pos === 0) {
             while (num--)
                 this.unshift(element);
         }
-        else if (pos === this._size) {
+        else if (pos === this._length) {
             while (num--)
                 this.push(element);
         }
         else {
             const arr = [];
-            for (let i = pos; i < this._size; ++i) {
+            for (let i = pos; i < this._length; ++i) {
                 arr.push(this.at(i));
             }
             this.cut(pos - 1, true);
@@ -453,17 +474,69 @@ class Deque extends base_1.IterableElementBase {
             const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
             this._bucketLast = bucketIndex;
             this._lastInBucket = indexInBucket;
-            this._size = pos + 1;
+            this._length = pos + 1;
             return this;
         }
         else {
-            const newDeque = new Deque([], { bucketSize: this._bucketSize });
+            const newDeque = this._createInstance({
+                bucketSize: this._bucketSize,
+                toElementFn: this._toElementFn,
+                maxLen: this._maxLen
+            });
             for (let i = 0; i <= pos; i++) {
                 newDeque.push(this.at(i));
             }
             return newDeque;
         }
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The `splice` function in TypeScript overrides the default behavior to remove and insert elements
+     * in a Deque data structure while ensuring the starting position and delete count are within bounds.
+     * @param {number} start - The `start` parameter in the `splice` method represents the index at which
+     * to start changing the array. Items will be removed or added starting from this index.
+     * @param {number} deleteCount - The `deleteCount` parameter in the `splice` method represents the
+     * number of elements to remove from the array starting at the specified `start` index. If
+     * `deleteCount` is not provided, it defaults to the number of elements from the `start` index to the
+     * end of the array (`
+     * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+     * will be inserted into the deque at the specified `start` index. These elements will be inserted in
+     * place of the elements that are removed based on the `start` and `deleteCount` parameters.
+     * @returns The `splice` method is returning the array `deletedElements` which contains the elements
+     * that were removed from the Deque during the splice operation.
+     */
+    splice(start, deleteCount = this._length - start, ...items) {
+        // Check whether the starting position is legal
+        (0, utils_1.rangeCheck)(start, 0, this._length);
+        // Adjust the value of deleteCount
+        if (deleteCount < 0)
+            deleteCount = 0;
+        if (start + deleteCount > this._length)
+            deleteCount = this._length - start;
+        // Save deleted elements
+        const deletedElements = this._createInstance();
+        // Add removed elements to the result
+        for (let i = 0; i < deleteCount; i++) {
+            deletedElements.push(this.at(start + i));
+        }
+        // Calculate the range that needs to be deleted
+        const elementsAfter = [];
+        for (let i = start + deleteCount; i < this._length; i++) {
+            elementsAfter.push(this.at(i));
+        }
+        // Adjust the length of the current Deque
+        this.cut(start - 1, true);
+        for (const item of items) {
+            this.push(item);
+        }
+        // Insert subsequent elements back
+        for (const element of elementsAfter) {
+            this.push(element);
+        }
+        return deletedElements;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1) or O(n)
@@ -487,14 +560,18 @@ class Deque extends base_1.IterableElementBase {
             const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
             this._bucketFirst = bucketIndex;
             this._firstInBucket = indexInBucket;
-            this._size = this._size - pos;
+            this._length = this._length - pos;
             return this;
         }
         else {
-            const newDeque = new Deque([], { bucketSize: this._bucketSize });
+            const newDeque = this._createInstance({
+                bucketSize: this._bucketSize,
+                toElementFn: this._toElementFn,
+                maxLen: this._maxLen
+            });
             if (pos < 0)
                 pos = 0;
-            for (let i = pos; i < this._size; i++) {
+            for (let i = pos; i < this._length; i++) {
                 newDeque.push(this.at(i));
             }
             return newDeque;
@@ -512,23 +589,32 @@ class Deque extends base_1.IterableElementBase {
      * @returns The size of the data structure after the deletion operation is performed.
      */
     deleteAt(pos) {
-        (0, utils_1.rangeCheck)(pos, 0, this._size - 1);
-        if (pos === 0)
-            this.shift();
-        else if (pos === this._size - 1)
+        (0, utils_1.rangeCheck)(pos, 0, this._length - 1);
+        let deleted;
+        if (pos === 0) {
+            //If it is the first element, use shift() directly
+            return this.shift();
+        }
+        else if (pos === this._length - 1) {
+            // If it is the last element, just use pop()
+            deleted = this.last;
             this.pop();
+            return deleted;
+        }
         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);
+            // Delete the middle element
+            const length = this._length - 1;
+            const { bucketIndex: targetBucket, indexInBucket: targetPointer } = this._getBucketAndPosition(pos);
+            deleted = this._buckets[targetBucket][targetPointer];
+            for (let i = pos; i < length; i++) {
+                const { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(i);
+                const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(i + 1);
                 this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];
-                curBucket = nextBucket;
-                curPointer = nextPointer;
             }
+            // Remove last duplicate element
             this.pop();
+            return deleted;
         }
-        return true;
     }
     /**
      * Time Complexity: O(n)
@@ -541,7 +627,7 @@ class Deque extends base_1.IterableElementBase {
      * @returns The size of the data structure after the element has been deleted.
      */
     delete(element) {
-        const size = this._size;
+        const size = this._length;
         if (size === 0)
             return false;
         let i = 0;
@@ -557,6 +643,42 @@ class Deque extends base_1.IterableElementBase {
         this.cut(index - 1, true);
         return true;
     }
+    // /**
+    //  * Time Complexity: O(n)
+    //  * Space Complexity: O(1)
+    //  *
+    //  * This function overrides the indexOf method to search for an element within a custom data
+    //  * structure.
+    //  * @param {E} searchElement - The `searchElement` parameter is the element that you are searching for
+    //  * within the data structure. The `indexOf` method will return the index of the first occurrence of
+    //  * this element within the data structure.
+    //  * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` method specifies the
+    //  * index at which to start searching for the `searchElement` within the data structure. If provided,
+    //  * the search will begin at this index instead of the beginning of the data structure.
+    //  * @returns The indexOf method is returning the index of the searchElement if it is found in the data
+    //  * structure, or -1 if the searchElement is not found.
+    //  */
+    // override indexOf(searchElement: E, fromIndex: number = 0): number {
+    //   let index = fromIndex;
+    //   let bucketIndex = this._bucketFirst;
+    //   let indexInBucket = this._firstInBucket + fromIndex;
+    //
+    //   for (let i = 0; i < this._length; i++) {
+    //     if (this._buckets[bucketIndex][indexInBucket] === searchElement) {
+    //       return index;
+    //     }
+    //     index++;
+    //     indexInBucket++;
+    //     if (indexInBucket >= this._bucketSize) {
+    //       bucketIndex++;
+    //       indexInBucket = 0;
+    //     }
+    //     if (bucketIndex >= this._bucketCount) {
+    //       bucketIndex = 0;
+    //     }
+    //   }
+    //   return -1;
+    // }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -586,12 +708,12 @@ class Deque extends base_1.IterableElementBase {
      * @returns The size of the modified array is being returned.
      */
     unique() {
-        if (this._size <= 1) {
+        if (this._length <= 1) {
             return this;
         }
         let index = 1;
         let prev = this.at(0);
-        for (let i = 1; i < this._size; ++i) {
+        for (let i = 1; i < this._length; ++i) {
             const cur = this.at(i);
             if (cur !== prev) {
                 prev = cur;
@@ -601,27 +723,6 @@ class Deque extends base_1.IterableElementBase {
         this.cut(index - 1, true);
         return this;
     }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `sort` function sorts the elements in a data structure using a provided comparator function.
-     * @param [comparator] - The `comparator` parameter is a function that takes in two elements `x` and
-     * `y` of type `E` and returns a number. The comparator function is used to determine the order of
-     * the elements in the sorted array.
-     * @returns Deque<E>
-     */
-    sort(comparator) {
-        const arr = [];
-        for (let i = 0; i < this._size; ++i) {
-            arr.push(this.at(i));
-        }
-        arr.sort(comparator);
-        for (let i = 0; i < this._size; ++i) {
-            this.setAt(i, arr[i]);
-        }
-        return this;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -629,10 +730,10 @@ class Deque extends base_1.IterableElementBase {
      * The `shrinkToFit` function reorganizes the elements in an array-like data structure to minimize
      * memory usage.
      * @returns Nothing is being returned. The function is using the `return` statement to exit early if
-     * `this._size` is 0, but it does not return any value.
+     * `this._length` is 0, but it does not return any value.
      */
     shrinkToFit() {
-        if (this._size === 0)
+        if (this._length === 0)
             return;
         const newBuckets = [];
         if (this._bucketFirst === this._bucketLast)
@@ -654,35 +755,6 @@ class Deque extends base_1.IterableElementBase {
         this._bucketLast = newBuckets.length - 1;
         this._buckets = newBuckets;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function "indexOf" returns the index of the first occurrence of a given element in an array,
-     * or -1 if the element is not found.
-     * @param {E} element - The "element" parameter represents the element that you want to find the
-     * index of in the data structure.
-     * @returns The indexOf function returns the index of the first occurrence of the specified element
-     * in the data structure. If the element is not found, it returns -1.
-     */
-    indexOf(element) {
-        for (let i = 0; i < this._size; ++i) {
-            if (this.at(i) === element) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `toArray` function converts the elements of a data structure into an array.
-     * @returns The `toArray()` method is returning an array of elements of type `E`.
-     */
-    toArray() {
-        return [...this];
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -693,7 +765,11 @@ class Deque extends base_1.IterableElementBase {
      * elements as the original deque (`this`) and the same bucket size.
      */
     clone() {
-        return new Deque(this, { bucketSize: this.bucketSize, toElementFn: this.toElementFn });
+        return new Deque(this, {
+            bucketSize: this.bucketSize,
+            toElementFn: this.toElementFn,
+            maxLen: this._maxLen
+        });
     }
     /**
      * Time Complexity: O(n)
@@ -712,7 +788,11 @@ class Deque extends base_1.IterableElementBase {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-        const newDeque = new Deque([], { bucketSize: this._bucketSize, toElementFn: this.toElementFn });
+        const newDeque = this._createInstance({
+            bucketSize: this._bucketSize,
+            toElementFn: this.toElementFn,
+            maxLen: this._maxLen
+        });
         let index = 0;
         for (const el of this) {
             if (predicate.call(thisArg, el, index, this)) {
@@ -741,7 +821,7 @@ class Deque extends base_1.IterableElementBase {
      * @returns a new Deque object with elements of type EM and raw elements of type RM.
      */
     map(callback, toElementFn, thisArg) {
-        const newDeque = new Deque([], { bucketSize: this._bucketSize, toElementFn });
+        const newDeque = new Deque([], { bucketSize: this._bucketSize, toElementFn, maxLen: this._maxLen });
         let index = 0;
         for (const el of this) {
             newDeque.push(callback.call(thisArg, el, index, this));
@@ -757,7 +837,7 @@ class Deque extends base_1.IterableElementBase {
      * object to be iterated over using a for...of loop.
      */
     *_getIterator() {
-        for (let i = 0; i < this._size; ++i) {
+        for (let i = 0; i < this._length; ++i) {
             yield this.at(i);
         }
     }
@@ -814,5 +894,25 @@ class Deque extends base_1.IterableElementBase {
         }
         return { bucketIndex, indexInBucket };
     }
+    /**
+     * The function `_createInstance` returns a new instance of the `Deque` class with the specified
+     * options.
+     * @param [options] - The `options` parameter in the `_createInstance` method is of type
+     * `DequeOptions<E, R>`, which is an optional parameter that allows you to pass additional
+     * configuration options when creating a new instance of the `Deque` class.
+     * @returns An instance of the `Deque` class with an empty array and the provided options, casted as
+     * `this`.
+     */
+    _createInstance(options) {
+        return new Deque([], options);
+    }
+    /**
+     * This function returns an iterator that iterates over elements in reverse order.
+     */
+    *_getReverseIterator() {
+        for (let i = this._length - 1; i > -1; i--) {
+            yield this.at(i);
+        }
+    }
 }
 exports.Deque = Deque;