Linked Lsit Queue

1. Design a queue using a linked list.

The implementation should support the following operations in O(1) time:

• enqueue(x): Add element x to the rear of the queue.
• dequeue(): Remove and return the front element of the queue.
• peek(): Return the front element without removing it.
• isEmpty(): Return true if the queue is empty, otherwise false.

Reverse Queue

2. Given a queue. Design an algorithm that returns the queue with elements in reverse order.

Circular Queue

3. Design and implement a Circular Queue data structure that uses a fixed-size array as underlying storage. The queue must behave in a circular manner — when the end of the array is reached, it wraps around to reuse empty slots at the beginning.

The data structure should support the following operations in constant time (O(1)):

• enqueue(value) – Add an element to the rear of the queue.
• dequeue() – Remove the front element from the queue.
• front() – Retrieve the front element (without removing it).
• rear() – Retrieve the rear element (without removing it).
• isEmpty() – Return true if the queue is empty; otherwise, false.
• isFull() – Return true if the queue is full; otherwise, false.

Two-Stack Queue Design

4. Design an algorithm that will implement first-in-first-out (FIFO) queue using two stacks.

The data structure should support the following operations:

• enqueue(x) - Add element x to the back of the queue.
• dequeue() - Removes the element from the front of the queue and returns it.
• peek() - Get the front element.
• isEmpty() - Return whether the queue is Empty.

BFS using Queue

1. Given an unweighted graph represented as an adjacency list, and two nodes start and end.

Design an algorithm using Breadth- First Search (BFS) and a queue to return the shortest path (in terms of number of edges) from start to end. Id no path exists, return null.

The algorithm should return the path as an array of nodes from start to end, inclusive.

Level Order of Tree

2. Given the root of a binary tree. Design an algorithm that performs a level order traversal using a queue and return a list of node values level by level from top to bottom from left to right.

 class TreeNode {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}

Sliding Window Maximum

3. Given an array of integers nums and an integer k, design an efficient algorithm that returns an array of the maximum values in every sliding window of size k, as the window moves from left to right across nums.

Each window must contain exactly k elements. The output should have (n - k + 1) elements, where n is the length of nums.

LIFO from FIFO

4. Design an algorithm that implements a Stack (LIFO) using one ot two queues (FIFO).

The algorithm should support the standard stack operations:

• push(x): Push element x onto the stack.
• pop(): Removes the element on the top of the stack.
• top(): Get the top element.
• isEmpty() Return wheter the stack is empty.

Binary Numbers from 1 to N

5. Given an integer 'N'. Design an algorithm that generates binary representations of all numbers from 1 to N in order, in numerical order.

Return the result as an array of binary strings.

1st Non-Repeating Character

6. Given a continuous stream of lowercase English characters, design an algorithm that returns a string where the i-th character represents the first non-repeating character in the stream up to index i. If no non-repeating character exists at a given point, return "#" for that position.

Rotten Oranges

7. Given a 2D Array Grid where each cell can have one of three values:

• 0: Empty Cell
• 1: Fresh Cell
• 2: Rotten Cell

Every minute, any fresh orange that is adjacent (4-directionally) to a rotten orange becomes rotten.

Design an algorithm that compute the minimum number of minutes that must elapse until no cell has a fresh orange. If it is impossible to rot all oranges, return -1.