doubly-linked-list-typed 1.54.3 → 2.0.1

package/dist/data-structures/priority-queue/min-priority-queue.d.ts

@@ -46,7 +46,7 @@ export declare class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E,
      * @returns The `filter` method is returning a new `MinPriorityQueue` object that contains the elements that pass
      * the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, R, boolean, MinPriorityQueue<E, R>>, thisArg?: any): MinPriorityQueue<E, R>;
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MinPriorityQueue<E, R>;
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -68,5 +68,5 @@ export declare class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E,
      * value of
      * @returns a new instance of the `MinPriorityQueue` class with the mapped elements.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, MinPriorityQueue<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MinPriorityQueue<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): MinPriorityQueue<EM, RM>;
 }

package/dist/data-structures/priority-queue/priority-queue.d.ts

@@ -48,7 +48,7 @@ export declare class PriorityQueue<E = any, R = any> extends Heap<E, R> {
      * @returns The `filter` method is returning a new `PriorityQueue` object that contains the elements that pass
      * the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, R, boolean, PriorityQueue<E, R>>, thisArg?: any): PriorityQueue<E, R>;
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): PriorityQueue<E, R>;
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -70,5 +70,5 @@ export declare class PriorityQueue<E = any, R = any> extends Heap<E, R> {
      * value of
      * @returns a new instance of the `PriorityQueue` class with the mapped elements.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, PriorityQueue<E, R>>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): PriorityQueue<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): PriorityQueue<EM, RM>;
 }

package/dist/data-structures/queue/deque.d.ts

@@ -6,15 +6,103 @@
  * @license MIT License
  */
 import type { DequeOptions, ElementCallback, IterableWithSizeOrLength } from '../../types';
-import { IterableElementBase } from '../base';
+import { LinearBase } from '../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]
  */
-export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E, R>> {
+export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
     /**
      * 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
@@ -28,63 +116,21 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      */
     constructor(elements?: IterableWithSizeOrLength<E> | IterableWithSizeOrLength<R>, options?: DequeOptions<E, R>);
     protected _bucketSize: number;
-    /**
-     * The bucketSize function returns the size of the bucket.
-     *
-     * @return The size of the bucket
-     */
     get bucketSize(): number;
-    protected _maxLen: number;
-    /**
-     * The maxLen function returns the max length of the deque.
-     *
-     * @return The max length of the deque
-     */
-    get maxLen(): number;
     protected _bucketFirst: number;
-    /**
-     * The function returns the value of the protected variable `_bucketFirst`.
-     * @returns The value of the `_bucketFirst` property.
-     */
     get bucketFirst(): number;
     protected _firstInBucket: number;
-    /**
-     * 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(): number;
     protected _bucketLast: number;
-    /**
-     * The function returns the value of the protected variable `_bucketLast`.
-     * @returns The value of the `_bucketLast` property, which is a number.
-     */
     get bucketLast(): number;
     protected _lastInBucket: number;
-    /**
-     * 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(): number;
     protected _bucketCount: number;
-    /**
-     * The function returns the number of buckets.
-     * @returns The number of buckets.
-     */
     get bucketCount(): number;
     protected _buckets: E[][];
-    /**
-     * The buckets function returns the buckets property of the object.
-     * @return The buckets property
-     */
     get buckets(): E[][];
-    protected _size: number;
-    /**
-     * The size function returns the number of items in the stack.
-     * @return The number of values in the set
-     */
-    get size(): number;
+    protected _length: number;
+    get length(): number;
     /**
      * The function returns the first element in a collection if it exists, otherwise it returns
      * undefined.
@@ -181,15 +227,6 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      * values.
      */
     clear(): void;
-    /**
-     * The below function is a generator that yields elements from a collection one by one.
-     */
-    begin(): Generator<E>;
-    /**
-     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
-     * the last element.
-     */
-    reverseBegin(): Generator<E>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -240,6 +277,25 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      * @returns The method is returning the updated size of the data structure.
      */
     cut(pos: number, isCutSelf?: boolean): Deque<E>;
+    /**
+     * 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: number, deleteCount?: number, ...items: E[]): this;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1) or O(n)
@@ -267,7 +323,7 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      * the index of the element to be deleted.
      * @returns The size of the data structure after the deletion operation is performed.
      */
-    deleteAt(pos: number): boolean;
+    deleteAt(pos: number): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -298,17 +354,6 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      * @returns The size of the modified array is being returned.
      */
     unique(): 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?: (x: E, y: E) => number): this;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -316,29 +361,9 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      * 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(): void;
-    /**
-     * 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: E): number;
-    /**
-     * 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(): E[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -348,7 +373,7 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      * @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(): Deque<E, R>;
+    clone(): this;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -365,7 +390,7 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      * @returns The `filter` method is returning a new `Deque` object that contains the elements that
      * satisfy the given predicate function.
      */
-    filter(predicate: ElementCallback<E, R, boolean, Deque<E, R>>, thisArg?: any): Deque<E, R>;
+    filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): Deque<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -384,7 +409,7 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
      * value of
      * @returns a new Deque object with elements of type EM and raw elements of type RM.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, Deque<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Deque<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Deque<EM, RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -416,4 +441,18 @@ export declare class Deque<E = any, R = any> extends IterableElementBase<E, R, D
         bucketIndex: number;
         indexInBucket: number;
     };
+    /**
+     * 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`.
+     */
+    protected _createInstance(options?: DequeOptions<E, R>): this;
+    /**
+     * This function returns an iterator that iterates over elements in reverse order.
+     */
+    protected _getReverseIterator(): IterableIterator<E>;
 }