• Logic:
  Fixed-size array with front and rear pointers.

• Mini Code:

int arr[] = new int[size];
int front = 0, rear = 0;

void enqueue(int x) {
    arr[rear++] = x;
}

int dequeue() {
    return arr[front++];
}

Trick: Overflow if rear == size.

2. Queue Using Linked List

• Logic:
  Dynamic nodes with front and rear pointers.

• Mini Code:

class Node {
    int data;
    Node next;
}
Node front = null, rear = null;

void enqueue(int x) {
    Node temp = new Node();
    temp.data = x;
    if (rear == null) front = rear = temp;
    else {
        rear.next = temp;
        rear = temp;
    }
}

int dequeue() {
    int val = front.data;
    front = front.next;
    if (front == null) rear = null;
    return val;
}

Trick: No size limit, dynamic memory.

🔥 Important Queue Problems (with mini code)

1️⃣ Implement Queue Using Stacks

• Logic: Use 2 stacks. Lazy transfer.

• Mini Code:

Stack<Integer> s1 = new Stack<>();
Stack<Integer> s2 = new Stack<>();

void enqueue(int x) {
    s1.push(x);
}

int dequeue() {
    if (s2.isEmpty()) 
        while (!s1.isEmpty()) s2.push(s1.pop());
    return s2.pop();
}

2️⃣ Implement Circular Queue

• Logic: (index + 1) % size.

• Mini Code:

int[] arr = new int[size];
int front = -1, rear = -1;

void enqueue(int x) {
    if ((rear + 1) % size == front) // full
    rear = (rear + 1) % size;
    arr[rear] = x;
    if (front == -1) front = 0;
}

int dequeue() {
    int val = arr[front];
    if (front == rear) front = rear = -1; // empty
    else front = (front + 1) % size;
    return val;
}

3️⃣ Level Order Traversal (Binary Tree)

• Logic: BFS

• Mini Code:

Queue<TreeNode> q = new LinkedList<>();
q.add(root);

while (!q.isEmpty()) {
    TreeNode node = q.poll();
    if (node.left != null) q.add(node.left);
    if (node.right != null) q.add(node.right);
}

4️⃣ First Non-Repeating Character (Stream)

• Logic: Queue + Freq count.

• Mini Code:

Queue<Character> q = new LinkedList<>();
int[] freq = new int[26];

for (char ch : stream) {
    freq[ch - 'a']++;
    q.add(ch);
    while (!q.isEmpty() && freq[q.peek() - 'a'] > 1) q.poll();
}

5️⃣ Sliding Window Maximum

• Logic: Deque for indices.

• Mini Code:

Deque<Integer> dq = new LinkedList<>();

for (int i = 0; i < n; i++) {
    if (!dq.isEmpty() && dq.peek() == i - k) dq.poll();
    while (!dq.isEmpty() && nums[dq.peekLast()] < nums[i]) dq.pollLast();
    dq.offer(i);
    if (i >= k - 1) ans.add(nums[dq.peek()]);
}

6️⃣ Rotten Oranges

• Logic: Multi-source BFS.

• Mini Code:

Queue<int[]> q = new LinkedList<>();

for (all rotten oranges) q.add({i, j, 0});

while (!q.isEmpty()) {
    int[] cell = q.poll();
    for (4 directions) {
        if (fresh orange) {
            grid[x][y] = 2;
            q.add({x, y, time+1});
        }
    }
}

7️⃣ Number of Islands

• Logic: BFS for every unvisited land.

• Mini Code:

for (i,j) {
    if (grid[i][j] == '1') {
        bfs(i, j);
        count++;
    }
}

void bfs(int i, int j) {
    Queue<int[]> q = new LinkedList<>();
    q.add({i,j});
    while (!q.isEmpty()) {
        int[] cell = q.poll();
        mark visited;
        add all 4 neighbors if '1'
    }
}

8️⃣ Reverse a Queue

• Logic: Recursion or Stack.

• Mini Code:

void reverse(Queue<Integer> q) {
    if (q.isEmpty()) return;
    int x = q.poll();
    reverse(q);
    q.add(x);
}

9️⃣ Generate Binary Numbers from 1 to N

• Logic: BFS of strings.

• Mini Code:

Queue<String> q = new LinkedList<>();
q.add("1");

while (n-- > 0) {
    String s1 = q.poll();
    System.out.println(s1);
    q.add(s1 + "0");
    q.add(s1 + "1");
}

🧠 Full Summary Table

Final Tip

Jaise hi "Level Order", "Stream", "Window", "Propagation", "Islands" suno —
Queue / Deque / BFS ka flash hona chahiye! 🚀

🧠 Why Stack?

Stacks are perfect when you need a Last-In-First-Out (LIFO) structure. That means when you go into a nested structure or a new "context," you can push it onto the stack, and when you're done, pop it back out in the correct order.

🔄 1. Decode String

Example: "3[a2[c]]" → "accaccacc"

🤔 Problem:

You're given a string with numbers and brackets. The goal is to decode it.

🕵️‍ Solution Intuition:

• Use a count stack to store repeat numbers.

• Use a string stack to store the previous string context.

• When you hit ']', you pop the top count and string, repeat the current segment, and combine.

🔍 2. Valid Parentheses

Example: "({[]})" → Valid

📄 Problem:

Check if every opening bracket has a matching closing bracket.

🏛️ Solution Intuition:

• Push opening brackets to the stack.

• On closing bracket, check if it matches the top of the stack.

• If mismatched or stack is not empty at end, it's invalid.

📊 3. Evaluate Reverse Polish Notation

Example: ["2", "1", "+", "3", "*"] → (2 + 1) * 3 = 9

🔎 Problem:

Evaluate a postfix expression.

⚖️ Solution Intuition:

• Push numbers to the stack.

• When an operator appears, pop the top two numbers, apply the operation, and push the result.

🔠 4. Simplify Unix-Style Path

Example: "/a/./b/../../c/" → "/c"

🤝 Problem:

Simplify a string representing a Unix-style path.

🔧 Solution Intuition:

• Split the path by '/' and use a stack.

• If you see "..", pop from the stack.

• If you see a valid folder, push it.

• Join the stack with '/' at the end.

🌟 5. Remove All Adjacent Duplicates

Example: "abbaca" → "ca"

❌ Problem:

Remove characters that appear consecutively.

🏠 Solution Intuition:

• Use a stack.

• If the current character matches the top, pop it.

• Else, push it.

📌 Bonus: Quick Self-Checklist Before Choosing Stack

🔹 Common Patterns To Memorize

// Decode String
char = digit → store k
char = '['   → push k & current, reset current
char = letter → append to current
char = ']'   → pop k & prev, repeat current and append

// Valid Parentheses
if opening bracket → push
if closing → match with top

// Postfix Eval
if number → push
if operator → pop 2, apply, push result

// Simplify Path
split by '/'
if ".." → pop
if valid folder → push

📚 Final Tip:

Practicing stack problems improves pattern recognition over time. Once you see brackets or nested structure, your brain will automatically say: "Stack time!"

Want to take it further? Try LeetCode problems like:

• Decode String

• Simplify Path

• Valid Parentheses

• Basic Calculator II

• Remove All Adjacent Duplicates

Save this cheat sheet. It’s your Stack Survival Kit ⛏️ for string-based problems!