Queue vs Stack When to Use Which in DSA C# - Key Differences

Recall & Review

beginner

What is the main difference between a Queue and a Stack?

A Queue follows First-In-First-Out (FIFO) order, meaning the first element added is the first to be removed. A Stack follows Last-In-First-Out (LIFO) order, meaning the last element added is the first to be removed.

beginner

When should you use a Queue?

Use a Queue when you need to process items in the order they arrive, like waiting lines, task scheduling, or breadth-first search in graphs.

beginner

When is a Stack the better choice?

Use a Stack when you need to reverse order or track recent actions, such as undo features, expression evaluation, or depth-first search in graphs.

intermediate

How does a Stack help in undo operations?

A Stack stores recent actions so the last action can be undone first, following LIFO order, making it easy to reverse steps in the correct order.

intermediate

Why is a Queue suitable for task scheduling?

A Queue processes tasks in the order they arrive (FIFO), ensuring fairness and that older tasks are handled before newer ones.

Which data structure removes the most recently added element first?

A Queue

B Stack

C Linked List

D Array

A Stack removes the last element added first, following Last-In-First-Out (LIFO) order.

Which data structure is best for processing tasks in the order they arrive?

A Stack

B Tree

C Queue

D Graph

A Queue processes elements in First-In-First-Out (FIFO) order, so tasks are handled in arrival order.

What is a common use case for a Stack?

A Breadth-first search

B Priority queue

C Task scheduling

D Undo functionality

Stacks are used for undo features because they reverse the order of actions using LIFO.

Which data structure would you use for breadth-first search in a graph?

A Queue

B Set

C Hash Table

D Stack

Breadth-first search uses a Queue to explore nodes level by level in FIFO order.

If you want to reverse the order of elements, which data structure helps best?

A Stack

B Queue

C Array

D Linked List

A Stack reverses order because it removes the last element added first (LIFO).

Explain when you would choose a Queue over a Stack and why.

Think about fairness and order of processing.

Describe a real-life scenario where a Stack is useful and how it works.

Consider how recent actions are undone.

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