data-structure-typed 2.4.5 → 2.5.0

package/src/data-structures/queue/deque.ts

@@ -27,71 +27,6 @@ import { LinearBase } from '../base/linear-base';
  * 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
- * // basic Deque creation and push/pop operations
- *  // Create a simple Deque with initial values
- *     const deque = new Deque([1, 2, 3, 4, 5]);
- *
- *     // Verify the deque maintains insertion order
- *     console.log([...deque]); // [1, 2, 3, 4, 5];
- *
- *     // Check length
- *     console.log(deque.length); // 5;
- *
- *     // Push to the end
- *     deque.push(6);
- *     console.log(deque.length); // 6;
- *
- *     // Pop from the end
- *     const last = deque.pop();
- *     console.log(last); // 6;
- * @example
- * // Deque shift and unshift operations
- *  const deque = new Deque<number>([20, 30, 40]);
- *
- *     // Unshift adds to the front
- *     deque.unshift(10);
- *     console.log([...deque]); // [10, 20, 30, 40];
- *
- *     // Shift removes from the front (O(1) complexity!)
- *     const first = deque.shift();
- *     console.log(first); // 10;
- *
- *     // Verify remaining elements
- *     console.log([...deque]); // [20, 30, 40];
- *     console.log(deque.length); // 3;
- * @example
- * // Deque peek at both ends
- *  const deque = new Deque<number>([10, 20, 30, 40, 50]);
- *
- *     // Get first element without removing
- *     const first = deque.at(0);
- *     console.log(first); // 10;
- *
- *     // Get last element without removing
- *     const last = deque.at(deque.length - 1);
- *     console.log(last); // 50;
- *
- *     // Length unchanged
- *     console.log(deque.length); // 5;
- * @example
- * // Deque for...of iteration and reverse
- *  const deque = new Deque<string>(['A', 'B', 'C', 'D']);
- *
- *     // Iterate forward
- *     const forward: string[] = [];
- *     for (const item of deque) {
- *       forward.push(item);
- *     }
- *     console.log(forward); // ['A', 'B', 'C', 'D'];
- *
- *     // Reverse the deque
- *     deque.reverse();
- *     const backward: string[] = [];
- *     for (const item of deque) {
- *       backward.push(item);
- *     }
- *     console.log(backward); // ['D', 'C', 'B', 'A'];
- * @example
  * // Deque as sliding window for stream processing
  *  interface DataPoint {
  *       timestamp: number;
@@ -142,6 +77,10 @@ import { LinearBase } from '../base/linear-base';
  *     console.log(windowResults[2].windowSize); // 3; // Windows are at max size from 3rd onwards
  *     console.log(windowResults[4].windowSize); // 3; // Last window still has 3 elements
  *     console.log(dataWindow.length); // 3;
+ * @example
+ * // Convert deque to array
+ *  const dq = new Deque<number>([10, 20, 30]);
+ *     console.log(dq.toArray()); // [10, 20, 30];
  */
 export class Deque<E = any, R = any> extends LinearBase<E, R> {
   protected _equals: (a: E, b: E) => boolean = (a, b) => Object.is(a, b);
@@ -310,6 +249,32 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * Get the first element without removing it.
    * @remarks Time O(1), Space O(1)
    * @returns First element or undefined.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Deque peek at both ends
+ *  const deque = new Deque<number>([10, 20, 30, 40, 50]);
+ *
+ *     // Get first element without removing
+ *     const first = deque.at(0);
+ *     console.log(first); // 10;
+ *
+ *     // Get last element without removing
+ *     const last = deque.at(deque.length - 1);
+ *     console.log(last); // 50;
+ *
+ *     // Length unchanged
+ *     console.log(deque.length); // 5;
    */
 
   get first(): E | undefined {
@@ -321,6 +286,23 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * Get the last element without removing it.
    * @remarks Time O(1), Space O(1)
    * @returns Last element or undefined.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Peek at the back element
+ *  const dq = new Deque<string>(['a', 'b', 'c']);
+ *     console.log(dq.last); // 'c';
+ *     console.log(dq.first); // 'a';
    */
 
   get last(): E | undefined {
@@ -355,6 +337,36 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * @remarks Time O(1) amortized, Space O(1)
    * @param element - Element to append.
    * @returns True when appended.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // basic Deque creation and push/pop operations
+ *  // Create a simple Deque with initial values
+ *     const deque = new Deque([1, 2, 3, 4, 5]);
+ *
+ *     // Verify the deque maintains insertion order
+ *     console.log([...deque]); // [1, 2, 3, 4, 5];
+ *
+ *     // Check length
+ *     console.log(deque.length); // 5;
+ *
+ *     // Push to the end
+ *     deque.push(6);
+ *     console.log(deque.length); // 6;
+ *
+ *     // Pop from the end
+ *     const last = deque.pop();
+ *     console.log(last); // 6;
    */
 
   push(element: E): boolean {
@@ -380,6 +392,23 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * Remove and return the last element.
    * @remarks Time O(1), Space O(1)
    * @returns Removed element or undefined.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Remove from the back
+ *  const dq = new Deque<number>([1, 2, 3]);
+ *     console.log(dq.pop()); // 3;
+ *     console.log(dq.length); // 2;
    */
 
   pop(): E | undefined {
@@ -405,6 +434,23 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * Remove and return the first element.
    * @remarks Time O(1) amortized, Space O(1)
    * @returns Removed element or undefined.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Remove from the front
+ *  const dq = new Deque<number>([1, 2, 3]);
+ *     console.log(dq.shift()); // 1;
+ *     console.log(dq.length); // 2;
    */
 
   shift(): E | undefined {
@@ -431,6 +477,33 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * @remarks Time O(1) amortized, Space O(1)
    * @param element - Element to prepend.
    * @returns True when prepended.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Deque shift and unshift operations
+ *  const deque = new Deque<number>([20, 30, 40]);
+ *
+ *     // Unshift adds to the front
+ *     deque.unshift(10);
+ *     console.log([...deque]); // [10, 20, 30, 40];
+ *
+ *     // Shift removes from the front (O(1) complexity!)
+ *     const first = deque.shift();
+ *     console.log(first); // 10;
+ *
+ *     // Verify remaining elements
+ *     console.log([...deque]); // [20, 30, 40];
+ *     console.log(deque.length); // 3;
    */
 
   unshift(element: E): boolean {
@@ -494,6 +567,20 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * Check whether the deque is empty.
    * @remarks Time O(1), Space O(1)
    * @returns True if length is 0.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Check if empty
+ *  const dq = new Deque();
+ *     console.log(dq.isEmpty()); // true;
    */
 
   isEmpty(): boolean {
@@ -504,6 +591,21 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * Remove all elements and reset structure.
    * @remarks Time O(1), Space O(1)
    * @returns void
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Remove all elements
+ *  const dq = new Deque<number>([1, 2, 3]);
+ *     dq.clear();
+ *     console.log(dq.length); // 0;
    */
 
   clear(): void {
@@ -518,6 +620,20 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * @remarks Time O(1), Space O(1)
    * @param pos - Zero-based position from the front.
    * @returns Element or undefined.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Access by index
+ *  const dq = new Deque<string>(['a', 'b', 'c']);
+ *     console.log(dq.at(0)); // 'a';
+ *     console.log(dq.at(2)); // 'c';
    */
 
   at(pos: number): E | undefined {
@@ -705,6 +821,20 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * @remarks Time O(N), Space O(1)
    * @param element - Element to remove (using the configured equality).
    * @returns True if an element was removed.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Remove element
+ *  const dq = new Deque<number>([1, 2, 3]);
+ *     dq.delete(2);
+ *     console.log(dq.length); // 2;
    */
 
   delete(element: E): boolean {
@@ -758,6 +888,36 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * Reverse the deque by reversing buckets and pointers.
    * @remarks Time O(N), Space O(N)
    * @returns This deque.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Deque for...of iteration and reverse
+ *  const deque = new Deque<string>(['A', 'B', 'C', 'D']);
+ *
+ *     // Iterate forward
+ *     const forward: string[] = [];
+ *     for (const item of deque) {
+ *       forward.push(item);
+ *     }
+ *     console.log(forward); // ['A', 'B', 'C', 'D'];
+ *
+ *     // Reverse the deque
+ *     deque.reverse();
+ *     const backward: string[] = [];
+ *     for (const item of deque) {
+ *       backward.push(item);
+ *     }
+ *     console.log(backward); // ['D', 'C', 'B', 'A'];
    */
 
   reverse(): this {
@@ -828,6 +988,22 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * Compact the deque by removing unused buckets.
    * @remarks Time O(N), Space O(1)
    * @returns True if compaction was performed (bucket count reduced).
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Reclaim memory
+ *  const dq = new Deque<number>([1, 2, 3, 4, 5]);
+ *     dq.shift();
+ *     dq.shift();
+ *     dq.compact();
+ *     console.log(dq.length); // 3;
    */
   compact(): boolean {
     const before = this._bucketCount;
@@ -861,6 +1037,23 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * Deep clone this deque, preserving options.
    * @remarks Time O(N), Space O(N)
    * @returns A new deque with the same content and options.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Create independent copy
+ *  const dq = new Deque<number>([1, 2, 3]);
+ *     const copy = dq.clone();
+ *     copy.pop();
+ *     console.log(dq.length); // 3;
+ *     console.log(copy.length); // 2;
    */
 
   clone(): this {
@@ -877,6 +1070,21 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * @param predicate - Predicate (value, index, deque) → boolean to keep element.
    * @param [thisArg] - Value for `this` inside the predicate.
    * @returns A new deque with kept elements.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Filter elements
+ *  const dq = new Deque<number>([1, 2, 3, 4]);
+ *     const result = dq.filter(x => x > 2);
+ *     console.log(result.length); // 2;
    */
 
   filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): this {
@@ -918,6 +1126,20 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
    * @param [options] - Options for the output deque (e.g., bucketSize, toElementFn, maxLen).
    * @param [thisArg] - Value for `this` inside the callback.
    * @returns A new Deque with mapped elements.
+   
+   
+   
+   
+   
+   
+   
+   
+   
+    * @example
+ * // Transform elements
+ *  const dq = new Deque<number>([1, 2, 3]);
+ *     const result = dq.map(x => x * 10);
+ *     console.log(result.toArray()); // [10, 20, 30];
    */
 
   map<EM, RM>(