Queue vs Stack When to Use Which in DSA C# - Compare & Choose

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Stack Operations

What is the printed output after executing the following C# code using a stack?

DSA C#

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        Stack<int> stack = new Stack<int>();
        stack.Push(10);
        stack.Push(20);
        stack.Push(30);
        Console.WriteLine(string.Join(" -> ", stack));
        stack.Pop();
        stack.Push(40);
        Console.WriteLine(string.Join(" -> ", stack));
    }
}

A

30 -> 20 -> 10
40 -> 20 -> 10

B

10 -> 20 -> 30
10 -> 20 -> 40

C

30 -> 20 -> 10
30 -> 20 -> 40

D

10 -> 20 -> 30
40 -> 30 -> 20

💡 Hint

Remember that Stack is Last In First Out (LIFO).

The stack prints elements from top to bottom. Initially, 30 is on top, then 20, then 10. After popping 30 and pushing 40, the top is 40, then 20, then 10.

❓ Predict Output

intermediate

Output of Queue Operations

What is the printed output after executing the following C# code using a queue?

DSA C#

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        Queue<string> queue = new Queue<string>();
        queue.Enqueue("A");
        queue.Enqueue("B");
        queue.Enqueue("C");
        Console.WriteLine(string.Join(" -> ", queue));
        queue.Dequeue();
        queue.Enqueue("D");
        Console.WriteLine(string.Join(" -> ", queue));
    }
}

A

B -> C -> A
C -> D -> A

B

C -> B -> A
D -> C -> B

C

A -> B -> C
B -> C -> D

D

A -> B -> C
A -> B -> C -> D

💡 Hint

Queue is First In First Out (FIFO).

The queue prints elements from front to back. Initially, A is front, then B, then C. After dequeuing A and enqueueing D, front is B, then C, then D.

🧠 Conceptual

advanced

Choosing Between Stack and Queue

Which data structure is best suited for implementing undo functionality in a text editor?

A Queue, because it follows First In First Out (FIFO) which processes actions in the order they were done.

B Stack, because it follows Last In First Out (LIFO) which allows undoing the most recent action first.

C Queue, because it allows random access to previous actions easily.

D Stack, because it processes actions in the order they were done.

💡 Hint

Undo means reversing the last action first.

Undo requires reversing the most recent action first, so LIFO behavior of stack fits perfectly.

🧠 Conceptual

advanced

When to Use Queue Instead of Stack

In which scenario is a queue more appropriate than a stack?

A Processing tasks in the order they arrive, like print jobs.

B Reversing a string character by character.

C Tracking function calls in recursion.

D Undoing the last typed character.

💡 Hint

Think about order of processing tasks.

Queues process items in the order they arrive (FIFO), ideal for tasks like print jobs.

🔧 Debug

expert

Identify the Error in Stack Usage

What error will occur when running this C# code snippet?

DSA C#

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        Stack<int> stack = new Stack<int>();
        stack.Push(1);
        stack.Pop();
        stack.Pop();
    }
}

A IndexOutOfRangeException because index is out of range.

B NullReferenceException because stack is null.

C No error, the code runs fine.

D InvalidOperationException because popping from an empty stack is not allowed.

💡 Hint

Check what happens when popping more times than pushed.

After popping the only element, the stack is empty. Another pop causes InvalidOperationException.

Practice

1. Which data structure should you use when you want to process items in the order they arrive, like customers in a line?

easy

A. Queue

B. Stack

C. Array

D. Dictionary

Solution

1. Step 1: Understand the order of processing

   Customers in a line are served in the order they arrive, which is First In First Out (FIFO).

2. Step 2: Match the data structure behavior

   A Queue follows FIFO, so it fits this scenario perfectly.

3. Final Answer:

   Queue -> Option A

4. Quick Check:

   FIFO = Queue [OK]

Hint: FIFO means use Queue, like a line of customers [OK]

Common Mistakes:

• Choosing Stack which is LIFO, not FIFO
• Confusing Array with order behavior
• Using Dictionary which is unordered

2. Which of the following is the correct way to add an item to a Stack in C#?

easy

A. stack.Enqueue(item);

B. stack.Add(item);

C. stack.Push(item);

D. stack.Insert(item);

Solution

1. Step 1: Recall Stack method names in C#

   Stack uses Push() to add items on top.

2. Step 2: Identify correct method

   Enqueue is for Queue, Add and Insert are not Stack methods.

3. Final Answer:

   stack.Push(item); -> Option C

4. Quick Check:

   Push adds to Stack [OK]

Hint: Push adds to Stack; Enqueue adds to Queue [OK]

Common Mistakes:

• Using Enqueue with Stack
• Using Add or Insert which are not Stack methods
• Confusing method names between Stack and Queue

3. What will be the output of the following C# code?

var stack = new Stack<int>();
stack.Push(10);
stack.Push(20);
stack.Push(30);
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Peek());

medium

A. 10\n20

B. 30\n20

C. 30\n30

D. 20\n10

Solution

1. Step 1: Trace Push operations on Stack

   Push 10, then 20, then 30. Stack top is 30.

2. Step 2: Execute Pop and Peek

   Pop removes and returns 30. Peek returns current top which is now 20.

3. Final Answer:

   30\n20 -> Option B

4. Quick Check:

   Pop = 30, Peek = 20 [OK]

Hint: Pop removes top, Peek shows top without removing [OK]

Common Mistakes:

• Confusing Pop and Peek results
• Assuming Stack is FIFO
• Mixing up order of Push calls

4. The following code is intended to process tasks in the order they arrive. What is the error?

var stack = new Stack<string>();
stack.Push("Task1");
stack.Push("Task2");
stack.Push("Task3");
while(stack.Count > 0)
{
    Console.WriteLine(stack.Pop());
}

medium

A. Stack processes tasks in reverse order, not arrival order

B. Stack does not have Push method

C. Missing initialization of Stack

D. Pop method does not remove items

Solution

1. Step 1: Understand Stack order behavior

   Stack is Last In First Out (LIFO), so tasks are processed in reverse order.

2. Step 2: Identify mismatch with requirement

   Processing tasks in arrival order requires FIFO, so Stack is wrong choice here.

3. Final Answer:

   Stack processes tasks in reverse order, not arrival order -> Option A

4. Quick Check:

   Stack = LIFO, needs FIFO for arrival order [OK]

Hint: Stack reverses order; use Queue for arrival order [OK]

Common Mistakes:

• Thinking Stack processes FIFO
• Ignoring order requirement
• Assuming Pop does not remove items

5. You need to design a system that tracks browser history allowing users to go back to the previous page. Which data structure is best and why?

hard

A. Array, because it stores pages sequentially

B. Queue, because it processes pages in order visited

C. Dictionary, because it stores pages with keys

D. Stack, because it allows going back to the last visited page first

Solution

1. Step 1: Understand browser back behavior

   Going back means visiting the last page visited first, which is Last In First Out (LIFO).

2. Step 2: Match data structure to behavior

   Stack follows LIFO, so it fits the browser history back feature perfectly.

3. Final Answer:

   Stack, because it allows going back to the last visited page first -> Option D

4. Quick Check:

   LIFO = Stack for browser back [OK]

Hint: Back button = LIFO = Stack [OK]

Common Mistakes:

• Choosing Queue which is FIFO
• Using Dictionary which is unordered
• Assuming Array handles back navigation automatically