data-structure-typed 2.2.2 → 2.2.3

package/test/unit/data-structures/queue/deque.test.ts

@@ -813,93 +813,124 @@ describe('Deque', () => {
 });
 
 describe('classic uses', () => {
-  it('@example prize roulette', () => {
-    class PrizeRoulette {
-      private deque: Deque<string>;
+  it('@example basic Deque creation and push/pop operations', () => {
+    // Create a simple Deque with initial values
+    const deque = new Deque([1, 2, 3, 4, 5]);
 
-      constructor(prizes: string[]) {
-        // Initialize the deque with prizes
-        this.deque = new Deque<string>(prizes);
-      }
+    // Verify the deque maintains insertion order
+    expect([...deque]).toEqual([1, 2, 3, 4, 5]);
 
-      // Rotate clockwise to the right (forward)
-      rotateClockwise(steps: number): void {
-        const n = this.deque.length;
-        if (n === 0) return;
+    // Check length
+    expect(deque.length).toBe(5);
 
-        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
-        }
-      }
+    // Push to the end
+    deque.push(6);
+    expect(deque.length).toBe(6);
 
-      // Rotate counterclockwise to the left (backward)
-      rotateCounterClockwise(steps: number): void {
-        const n = this.deque.length;
-        if (n === 0) return;
+    // Pop from the end
+    const last = deque.pop();
+    expect(last).toBe(6);
+  });
 
-        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
-        }
-      }
+  it('@example Deque shift and unshift operations', () => {
+    const deque = new Deque<number>([20, 30, 40]);
 
-      // Display the current prize at the head
-      display() {
-        return this.deque.first;
-      }
-    }
+    // Unshift adds to the front
+    deque.unshift(10);
+    expect([...deque]).toEqual([10, 20, 30, 40]);
+
+    // Shift removes from the front (O(1) complexity!)
+    const first = deque.shift();
+    expect(first).toBe(10);
+
+    // Verify remaining elements
+    expect([...deque]).toEqual([20, 30, 40]);
+    expect(deque.length).toBe(3);
+  });
 
-    // Example usage
-    const prizes = ['Car', 'Bike', 'Laptop', 'Phone', 'Watch', 'Headphones']; // Initialize the prize list
-    const roulette = new PrizeRoulette(prizes);
+  it('@example Deque peek at both ends', () => {
+    const deque = new Deque<number>([10, 20, 30, 40, 50]);
 
-    // Display the initial state
-    expect(roulette.display()).toBe('Car'); // Car
+    // Get first element without removing
+    const first = deque.at(0);
+    expect(first).toBe(10);
 
-    // Rotate clockwise by 3 steps
-    roulette.rotateClockwise(3);
-    expect(roulette.display()).toBe('Phone'); // Phone
+    // Get last element without removing
+    const last = deque.at(deque.length - 1);
+    expect(last).toBe(50);
 
-    // Rotate counterclockwise by 2 steps
-    roulette.rotateCounterClockwise(2);
-    expect(roulette.display()).toBe('Headphones'); // Headphones
+    // Length unchanged
+    expect(deque.length).toBe(5);
   });
 
-  it('@example sliding window', () => {
-    // Maximum function of sliding window
-    function maxSlidingWindow(nums: number[], k: number): number[] {
-      const n = nums.length;
-      if (n * k === 0) return [];
+  it('@example Deque for...of iteration and reverse', () => {
+    const deque = new Deque<string>(['A', 'B', 'C', 'D']);
 
-      const deq = new Deque<number>();
-      const result: number[] = [];
+    // Iterate forward
+    const forward: string[] = [];
+    for (const item of deque) {
+      forward.push(item);
+    }
+    expect(forward).toEqual(['A', 'B', 'C', 'D']);
 
-      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();
-        }
+    // Reverse the deque
+    deque.reverse();
+    const backward: string[] = [];
+    for (const item of deque) {
+      backward.push(item);
+    }
+    expect(backward).toEqual(['D', 'C', 'B', 'A']);
+  });
 
-        // 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();
-        }
+  it('@example Deque as sliding window for stream processing', () => {
+    interface DataPoint {
+      timestamp: number;
+      value: number;
+      sensor: string;
+    }
 
-        // Add the current index to the end of the queue
-        deq.push(i);
+    // Create a deque-based sliding window for real-time data aggregation
+    const windowSize = 3;
+    const dataWindow = new Deque<DataPoint>();
 
-        // Add the maximum value of the window to the results
-        if (i >= k - 1) {
-          result.push(nums[deq.first!]);
-        }
+    // Simulate incoming sensor data stream
+    const incomingData: DataPoint[] = [
+      { timestamp: 1000, value: 25.5, sensor: 'temp-01' },
+      { timestamp: 1100, value: 26.2, sensor: 'temp-01' },
+      { timestamp: 1200, value: 25.8, sensor: 'temp-01' },
+      { timestamp: 1300, value: 27.1, sensor: 'temp-01' },
+      { timestamp: 1400, value: 26.9, sensor: 'temp-01' }
+    ];
+
+    const windowResults: Array<{ avgValue: number; windowSize: number }> = [];
+
+    for (const dataPoint of incomingData) {
+      // Add new data to the end
+      dataWindow.push(dataPoint);
+
+      // Remove oldest data when window exceeds size (O(1) from front)
+      if (dataWindow.length > windowSize) {
+        dataWindow.shift();
+      }
+
+      // Calculate average of current window
+      let sum = 0;
+      for (const point of dataWindow) {
+        sum += point.value;
       }
+      const avg = sum / dataWindow.length;
 
-      return result;
+      windowResults.push({
+        avgValue: Math.round(avg * 10) / 10,
+        windowSize: dataWindow.length
+      });
     }
 
-    const nums = [1, 3, -1, -3, 5, 3, 6, 7];
-    const k = 3;
-    expect(maxSlidingWindow(nums, k)).toEqual([3, 3, 5, 5, 6, 7]); // Output: [3, 3, 5, 5, 6, 7]
+    // Verify sliding window behavior
+    expect(windowResults.length).toBe(5);
+    expect(windowResults[0].windowSize).toBe(1); // First window has 1 element
+    expect(windowResults[2].windowSize).toBe(3); // Windows are at max size from 3rd onwards
+    expect(windowResults[4].windowSize).toBe(3); // Last window still has 3 elements
+    expect(dataWindow.length).toBe(3); // Final window contains last 3 elements
   });
 });

package/test/unit/data-structures/queue/queue.test.ts

@@ -594,76 +594,110 @@ describe('Queue', () => {
 });
 
 describe('classic uses', () => {
-  it('@example Sliding Window using Queue', () => {
-    const nums = [2, 3, 4, 1, 5];
-    const k = 2;
-    const queue = new Queue<number>();
+  it('@example basic Queue creation and push operation', () => {
+    // Create a simple Queue with initial values
+    const queue = new Queue([1, 2, 3, 4, 5]);
 
-    let maxSum = 0;
-    let currentSum = 0;
+    // Verify the queue maintains insertion order
+    expect([...queue]).toEqual([1, 2, 3, 4, 5]);
 
-    nums.forEach(num => {
-      queue.push(num);
-      currentSum += num;
+    // Check length
+    expect(queue.length).toBe(5);
+  });
 
-      if (queue.length > k) {
-        currentSum -= queue.shift()!;
-      }
+  it('@example Queue shift and peek operations', () => {
+    const queue = new Queue<number>([10, 20, 30, 40]);
 
-      if (queue.length === k) {
-        maxSum = Math.max(maxSum, currentSum);
-      }
-    });
+    // Peek at the front element without removing it
+    expect(queue.first).toBe(10);
+
+    // Remove and get the first element (FIFO)
+    const first = queue.shift();
+    expect(first).toBe(10);
 
-    expect(maxSum).toBe(7); // Maximum sum is from subarray [3, 4].
+    // Verify remaining elements and length decreased
+    expect([...queue]).toEqual([20, 30, 40]);
+    expect(queue.length).toBe(3);
   });
 
-  it('@example Breadth-First Search (BFS) using Queue', () => {
-    const graph: { [key in number]: number[] } = {
-      1: [2, 3],
-      2: [4, 5],
-      3: [],
-      4: [],
-      5: []
-    };
+  it('@example Queue for...of iteration and isEmpty check', () => {
+    const queue = new Queue<string>(['A', 'B', 'C', 'D']);
 
-    const queue = new Queue<number>();
-    const visited: number[] = [];
+    const elements: string[] = [];
+    for (const item of queue) {
+      elements.push(item);
+    }
 
-    queue.push(1);
+    // Verify all elements are iterated in order
+    expect(elements).toEqual(['A', 'B', 'C', 'D']);
 
-    while (!queue.isEmpty()) {
-      const node = queue.shift()!;
-      if (!visited.includes(node)) {
-        visited.push(node);
-        graph[node].forEach(neighbor => queue.push(neighbor));
-      }
+    // Process all elements
+    while (queue.length > 0) {
+      queue.shift();
     }
 
-    expect(visited).toEqual([1, 2, 3, 4, 5]); // Expected BFS traversal order.
+    expect(queue.length).toBe(0);
   });
 
-  it('Task Scheduling using Queue', () => {
-    const tasks = ['A', 'A', 'A', 'B', 'B', 'B'];
-    const cooldown = 2;
-
-    const taskQueue = new Queue<string>();
-    const cooldownQueue = new Queue<string>();
+  it('@example Queue as message broker for event processing', () => {
+    interface Message {
+      id: string;
+      type: 'email' | 'sms' | 'push';
+      recipient: string;
+      content: string;
+      timestamp: Date;
+    }
 
-    for (const task of tasks) {
-      while (!cooldownQueue.isEmpty() && cooldownQueue.first === task) {
-        cooldownQueue.shift();
-        taskQueue.push('idle');
+    // Create a message queue for real-time event processing
+    const messageQueue = new Queue<Message>([
+      {
+        id: 'msg-001',
+        type: 'email',
+        recipient: 'user@example.com',
+        content: 'Welcome!',
+        timestamp: new Date()
+      },
+      {
+        id: 'msg-002',
+        type: 'sms',
+        recipient: '+1234567890',
+        content: 'OTP: 123456',
+        timestamp: new Date()
+      },
+      {
+        id: 'msg-003',
+        type: 'push',
+        recipient: 'device-token-xyz',
+        content: 'New notification',
+        timestamp: new Date()
+      },
+      {
+        id: 'msg-004',
+        type: 'email',
+        recipient: 'admin@example.com',
+        content: 'Daily report',
+        timestamp: new Date()
       }
+    ]);
 
-      taskQueue.push(task);
-      cooldownQueue.push(task);
-      if (cooldownQueue.length > cooldown) {
-        cooldownQueue.shift();
+    // Process messages in FIFO order (first message first)
+    const processedMessages: string[] = [];
+    while (messageQueue.length > 0) {
+      const message = messageQueue.shift();
+      if (message) {
+        processedMessages.push(`${message.type}:${message.recipient}`);
       }
     }
 
-    const scheduled = taskQueue.elements;
-    expect(scheduled).toEqual(['A', 'idle', 'A', 'idle', 'A', 'B', 'B', 'idle', 'idle', 'B']);
+    // Verify messages were processed in order
+    expect(processedMessages).toEqual([
+      'email:user@example.com',
+      'sms:+1234567890',
+      'push:device-token-xyz',
+      'email:admin@example.com'
+    ]);
+
+    // Queue should be empty after processing all messages
+    expect(messageQueue.length).toBe(0);
   });
 });

package/test/unit/data-structures/stack/stack.test.ts

@@ -164,6 +164,50 @@ describe('Stack iterative methods', () => {
 });
 
 describe('classic uses', () => {
+  it('@example basic Stack creation and push operation', () => {
+    // Create a simple Stack with initial values
+    const stack = new Stack([1, 2, 3, 4, 5]);
+
+    // Verify the stack maintains insertion order (LIFO will be shown in pop)
+    expect([...stack]).toEqual([1, 2, 3, 4, 5]);
+
+    // Check length
+    expect(stack.size).toBe(5);
+
+    // Push a new element to the top
+    stack.push(6);
+    expect(stack.size).toBe(6);
+  });
+
+  it('@example Stack pop operation (LIFO - Last In First Out)', () => {
+    const stack = new Stack<number>([10, 20, 30, 40, 50]);
+
+    // Peek at the top element without removing
+    const top = stack.peek();
+    expect(top).toBe(50);
+
+    // Pop removes from the top (LIFO order)
+    const popped = stack.pop();
+    expect(popped).toBe(50);
+
+    // Next pop gets the previous element
+    const next = stack.pop();
+    expect(next).toBe(40);
+
+    // Verify length decreased
+    expect(stack.size).toBe(3);
+  });
+
+  it('@example Function Call Stack', () => {
+    const functionStack = new Stack<string>();
+    functionStack.push('main');
+    functionStack.push('foo');
+    functionStack.push('bar');
+    expect(functionStack.pop()).toBe('bar');
+    expect(functionStack.pop()).toBe('foo');
+    expect(functionStack.pop()).toBe('main');
+  });
+
   it('@example Balanced Parentheses or Brackets', () => {
     type ValidCharacters = ')' | '(' | ']' | '[' | '}' | '{';
 
@@ -197,21 +241,6 @@ describe('classic uses', () => {
     expect(stack.pop()).toBe(8);
   });
 
-  it('@example Depth-First Search (DFS)', () => {
-    const stack = new Stack<number>();
-    const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };
-    const visited: number[] = [];
-    stack.push(1);
-    while (!stack.isEmpty()) {
-      const node = stack.pop()!;
-      if (!visited.includes(node)) {
-        visited.push(node);
-        graph[node].forEach(neighbor => stack.push(neighbor));
-      }
-    }
-    expect(visited).toEqual([1, 3, 5, 2, 4]); // Example DFS order
-  });
-
   it('@example Backtracking Algorithms', () => {
     const stack = new Stack<[number, number]>();
     const maze = [
@@ -258,14 +287,18 @@ describe('classic uses', () => {
     expect(path).toContainEqual(end);
   });
 
-  it('@example Function Call Stack', () => {
-    const functionStack = new Stack<string>();
-    functionStack.push('main');
-    functionStack.push('foo');
-    functionStack.push('bar');
-    expect(functionStack.pop()).toBe('bar');
-    expect(functionStack.pop()).toBe('foo');
-    expect(functionStack.pop()).toBe('main');
+  it('@example Stock Span Problem', () => {
+    const stack = new Stack<number>();
+    const prices = [100, 80, 60, 70, 60, 75, 85];
+    const spans: number[] = [];
+    prices.forEach((price, i) => {
+      while (!stack.isEmpty() && prices[stack.peek()!] <= price) {
+        stack.pop();
+      }
+      spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);
+      stack.push(i);
+    });
+    expect(spans).toEqual([1, 1, 1, 2, 1, 4, 6]);
   });
 
   it('@example Simplify File Paths', () => {
@@ -278,18 +311,94 @@ describe('classic uses', () => {
     expect(stack.elements.join('/')).toBe('c');
   });
 
-  it('@example Stock Span Problem', () => {
+  it('Stack for function call stack simulation', () => {
+    interface CallFrame {
+      functionName: string;
+      lineNumber: number;
+      variables: Record<string, unknown>;
+      timestamp: number;
+    }
+
+    // Simulate a call stack for debugging/tracing
+    const callStack = new Stack<CallFrame>();
+
+    // Simulate function calls pushing frames onto stack
+    callStack.push({
+      functionName: 'main',
+      lineNumber: 1,
+      variables: { x: 10, y: 20 },
+      timestamp: 1000
+    });
+
+    callStack.push({
+      functionName: 'calculateSum',
+      lineNumber: 5,
+      variables: { a: 10, b: 20 },
+      timestamp: 1100
+    });
+
+    callStack.push({
+      functionName: 'helper',
+      lineNumber: 12,
+      variables: { result: 30 },
+      timestamp: 1200
+    });
+
+    // Verify current call frame
+    expect(callStack.size).toBe(3);
+    const currentFrame = callStack.peek();
+    expect(currentFrame?.functionName).toBe('helper');
+    expect(currentFrame?.lineNumber).toBe(12);
+
+    // Simulate function returns popping from stack (LIFO)
+    const returnedFrame = callStack.pop();
+    expect(returnedFrame?.functionName).toBe('helper');
+    expect(callStack.size).toBe(2);
+
+    // Next return
+    const nextReturn = callStack.pop();
+    expect(nextReturn?.functionName).toBe('calculateSum');
+
+    // Back to main
+    const mainFrame = callStack.pop();
+    expect(mainFrame?.functionName).toBe('main');
+
+    // Stack empty after all returns
+    expect(callStack.size).toBe(0);
+  });
+
+  it('Stack for...of iteration and isEmpty', () => {
+    const stack = new Stack<string>(['A', 'B', 'C', 'D']);
+
+    // Iterate through stack
+    const elements: string[] = [];
+    for (const item of stack) {
+      elements.push(item);
+    }
+    expect(elements).toEqual(['A', 'B', 'C', 'D']);
+
+    // Clear the stack
+    while (stack.size > 0) {
+      stack.pop();
+    }
+
+    // Stack is now empty
+    expect(stack.size).toBe(0);
+  });
+
+  it('Depth-First Search (DFS)', () => {
     const stack = new Stack<number>();
-    const prices = [100, 80, 60, 70, 60, 75, 85];
-    const spans: number[] = [];
-    prices.forEach((price, i) => {
-      while (!stack.isEmpty() && prices[stack.peek()!] <= price) {
-        stack.pop();
+    const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };
+    const visited: number[] = [];
+    stack.push(1);
+    while (!stack.isEmpty()) {
+      const node = stack.pop()!;
+      if (!visited.includes(node)) {
+        visited.push(node);
+        graph[node].forEach(neighbor => stack.push(neighbor));
       }
-      spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);
-      stack.push(i);
-    });
-    expect(spans).toEqual([1, 1, 1, 2, 1, 4, 6]);
+    }
+    expect(visited).toEqual([1, 3, 5, 2, 4]); // Example DFS order
   });
 
   it('Browser Navigation', () => {