Queue vs Stack When to Use Which in DSA C# - Build Both Approaches

Queue vs Stack: When to Use Which

📖 Scenario: Imagine you are organizing tasks for a small office. Some tasks need to be done in the order they arrive, like answering phone calls. Other tasks need to be done in reverse order, like undoing recent changes in a document.

🎯 Goal: You will create a simple program to manage tasks using both a queue and a stack. You will see how tasks are added and removed differently in each structure, helping you understand when to use a queue or a stack.

📋 What You'll Learn

Create a queue of string tasks called phoneCalls with exact tasks: "Call A", "Call B", "Call C"

Create a stack of string tasks called undoTasks with exact tasks: "Edit 1", "Edit 2", "Edit 3"

Dequeue one task from phoneCalls and pop one task from undoTasks

Print the remaining tasks in phoneCalls and undoTasks showing their order

💡 Why This Matters

🌍 Real World

Queues are used when order matters, like waiting in line or processing tasks in order. Stacks are used when you need to reverse actions, like undo features or backtracking.

💼 Career

Understanding queues and stacks helps in software development for managing tasks, memory, and user actions efficiently.

1

Create the initial task lists

Create a Queue<string> called phoneCalls and add these tasks in order: "Call A", "Call B", "Call C". Also create a Stack<string> called undoTasks and push these tasks in order: "Edit 1", "Edit 2", "Edit 3".

DSA C#

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Create phoneCalls queue and add tasks
        // Create undoTasks stack and push tasks
    }
}

Hint

Use Queue<string> and Stack<string> from System.Collections.Generic. Use Enqueue to add to queue and Push to add to stack.

2

Remove one task from each structure

Remove one task from phoneCalls using Dequeue() and store it in a variable called answeredCall. Remove one task from undoTasks using Pop() and store it in a variable called undoneEdit.

DSA C#

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Queue phoneCalls = new Queue();
        phoneCalls.Enqueue("Call A");
        phoneCalls.Enqueue("Call B");
        phoneCalls.Enqueue("Call C");

        Stack undoTasks = new Stack();
        undoTasks.Push("Edit 1");
        undoTasks.Push("Edit 2");
        undoTasks.Push("Edit 3");

        // Remove one task from phoneCalls and store in answeredCall
        // Remove one task from undoTasks and store in undoneEdit
    }
}

Hint

Use Dequeue() to remove the first item from the queue and Pop() to remove the last item from the stack.

3

Show remaining tasks in each structure

Use a foreach loop with variable call to iterate over phoneCalls and print each remaining task. Then use a foreach loop with variable edit to iterate over undoTasks and print each remaining task.

DSA C#

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Queue phoneCalls = new Queue();
        phoneCalls.Enqueue("Call A");
        phoneCalls.Enqueue("Call B");
        phoneCalls.Enqueue("Call C");

        Stack undoTasks = new Stack();
        undoTasks.Push("Edit 1");
        undoTasks.Push("Edit 2");
        undoTasks.Push("Edit 3");

        string answeredCall = phoneCalls.Dequeue();
        string undoneEdit = undoTasks.Pop();

        // Print remaining phoneCalls tasks
        // Print remaining undoTasks tasks
    }
}

Hint

Use foreach loops to go through each item and Console.WriteLine to print them.

4

Print the removed tasks

Print the variables answeredCall and undoneEdit using Console.WriteLine to show which tasks were removed from the queue and stack.

DSA C#

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Queue phoneCalls = new Queue();
        phoneCalls.Enqueue("Call A");
        phoneCalls.Enqueue("Call B");
        phoneCalls.Enqueue("Call C");

        Stack undoTasks = new Stack();
        undoTasks.Push("Edit 1");
        undoTasks.Push("Edit 2");
        undoTasks.Push("Edit 3");

        string answeredCall = phoneCalls.Dequeue();
        string undoneEdit = undoTasks.Pop();

        Console.WriteLine("Remaining phone calls:");
        foreach (string call in phoneCalls)
        {
            Console.WriteLine(call);
        }

        Console.WriteLine("Remaining undo tasks:");
        foreach (string edit in undoTasks)
        {
            Console.WriteLine(edit);
        }

        // Print answeredCall and undoneEdit
    }
}

Hint

Use Console.WriteLine with string interpolation to print the removed tasks.

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