Queue and Stack behavior in C Sharp (C#)

Introduction

Queues and stacks help us organize data in a specific order so we can add and remove items easily. They work like real-life lines or piles.

When you want to process tasks in the order they arrive, like people waiting in line at a store (Queue).

When you want to reverse the order of items, like stacking plates and taking the top one first (Stack).

When you need to undo actions, like pressing undo in a text editor (Stack).

When you want to handle requests in the order they come, like print jobs sent to a printer (Queue).

When you want to explore things step-by-step and backtrack, like navigating a maze (Stack).

Syntax

C Sharp (C#)

using System;
using System.Collections.Generic;

public class QueueAndStackDemo
{
    public static void Main()
    {
        // Queue example
        Queue<int> numberQueue = new Queue<int>();
        numberQueue.Enqueue(1); // Add to end
        numberQueue.Enqueue(2);
        int firstInQueue = numberQueue.Dequeue(); // Remove from front

        // Stack example
        Stack<int> numberStack = new Stack<int>();
        numberStack.Push(1); // Add to top
        numberStack.Push(2);
        int topOfStack = numberStack.Pop(); // Remove from top
    }
}

Queue uses FIFO (First In First Out) order: first added is first removed.

Stack uses LIFO (Last In First Out) order: last added is first removed.

Examples

Queue with strings. Items come out in the order they were added.

C Sharp (C#)

Queue<string> tasks = new Queue<string>();
tasks.Enqueue("Task1");
tasks.Enqueue("Task2");
string nextTask = tasks.Dequeue();

Stack with strings. Items come out in reverse order of adding.

C Sharp (C#)

Stack<string> history = new Stack<string>();
history.Push("Page1");
history.Push("Page2");
string lastPage = history.Pop();

Trying to remove from an empty queue causes an error.

C Sharp (C#)

Queue<int> emptyQueue = new Queue<int>();
// Dequeue on empty queue throws InvalidOperationException

Stack with one item. Pop removes that item, then stack is empty.

C Sharp (C#)

Stack<int> singleStack = new Stack<int>();
singleStack.Push(10);
int onlyItem = singleStack.Pop();

Sample Program

This program shows how a queue and a stack work. It adds items, shows them, removes one, then shows the remaining items.

C Sharp (C#)

using System;
using System.Collections.Generic;

public class QueueAndStackBehavior
{
    public static void Main()
    {
        // Create a queue and add items
        Queue<string> customerQueue = new Queue<string>();
        customerQueue.Enqueue("Alice");
        customerQueue.Enqueue("Bob");
        customerQueue.Enqueue("Charlie");

        Console.WriteLine("Queue before dequeue:");
        foreach (string customer in customerQueue)
        {
            Console.WriteLine(customer);
        }

        // Remove one item from queue
        string servedCustomer = customerQueue.Dequeue();
        Console.WriteLine($"\nServed customer: {servedCustomer}");

        Console.WriteLine("Queue after dequeue:");
        foreach (string customer in customerQueue)
        {
            Console.WriteLine(customer);
        }

        // Create a stack and add items
        Stack<string> bookStack = new Stack<string>();
        bookStack.Push("Book1");
        bookStack.Push("Book2");
        bookStack.Push("Book3");

        Console.WriteLine("\nStack before pop:");
        foreach (string book in bookStack)
        {
            Console.WriteLine(book);
        }

        // Remove one item from stack
        string topBook = bookStack.Pop();
        Console.WriteLine($"\nRemoved from stack: {topBook}");

        Console.WriteLine("Stack after pop:");
        foreach (string book in bookStack)
        {
            Console.WriteLine(book);
        }
    }
}

Important Notes

Queue operations Enqueue and Dequeue run in O(1) time.

Stack operations Push and Pop run in O(1) time.

Trying to Dequeue or Pop from an empty collection throws an exception; always check if empty first.

Use Queue when order matters and you want to process oldest items first.

Use Stack when you want to reverse order or track recent items first.

Summary

Queue follows FIFO: first added, first removed.

Stack follows LIFO: last added, first removed.

Both are useful for organizing data in different real-life scenarios.

Practice

1. Which data structure removes elements in the order they were added, like a line at a grocery store?

easy

A. Array

B. Stack

C. Dictionary

D. Queue

Solution

1. Step 1: Understand FIFO behavior

   A queue removes elements in the order they were added, called First-In-First-Out (FIFO).

2. Step 2: Match behavior to real-life example

   A line at a grocery store is FIFO, so the queue matches this behavior.

3. Final Answer:

   Queue -> Option D

4. Quick Check:

   FIFO = Queue [OK]

Hint: FIFO means first in, first out like a queue line [OK]

Common Mistakes:

• Confusing stack with queue
• Thinking stack is FIFO
• Mixing array behavior with queue
• Assuming dictionary has order

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

easy

A. stack.Push(item);

B. stack.Enqueue(item);

C. stack.Add(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 A

4. Quick Check:

   Push adds to Stack [OK]

Hint: Use Push() to add to Stack, Enqueue() for Queue [OK]

Common Mistakes:

• Using Enqueue() on Stack
• Using Add() or Insert() which don't exist
• Confusing Stack and Queue methods
• Syntax errors with method calls

3. What is the output of this C# code?

var stack = new Stack<int>();
stack.Push(1);
stack.Push(2);
stack.Push(3);
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Peek());

medium

A. 3\n2

B. 1\n2

C. 2\n3

D. 3\n3

Solution

1. Step 1: Trace Push operations

   Stack after pushes: bottom=1, middle=2, top=3.

2. Step 2: Execute Pop and Peek

   Pop() removes and returns top (3). Peek() returns new top (2) without removing.

3. Final Answer:

   3\n2 -> Option A

4. Quick Check:

   Pop=3, Peek=2 [OK]

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

Common Mistakes:

• Mixing Pop and Peek results
• Assuming FIFO order
• Confusing stack order
• Forgetting Pop removes item

4. Identify the error in this C# code using Queue:

var queue = new Queue<string>();
queue.Push("apple");
queue.Enqueue("banana");
Console.WriteLine(queue.Dequeue());

medium

A. Dequeue() returns last item added

B. Queue does not have Push() method

C. Enqueue() should be Dequeue()

D. Queue cannot store strings

Solution

1. Step 1: Check Queue methods

   Queue uses Enqueue() to add, not Push().

2. Step 2: Identify incorrect method usage

   Calling Push() on Queue causes a compile error.

3. Final Answer:

   Queue does not have Push() method -> Option B

4. Quick Check:

   Queue uses Enqueue, no Push [OK]

Hint: Queue uses Enqueue(), Stack uses Push() [OK]

Common Mistakes:

• Using Push() on Queue
• Confusing Enqueue and Dequeue
• Thinking Dequeue returns last item
• Assuming Queue can't hold strings

5. You want to reverse the order of words in a sentence using C#. Which data structure is best and why?

string sentence = "hello world from C#";

hard

A. Queue, because it keeps original order using FIFO

B. Dictionary, because it stores key-value pairs

C. Stack, because it reverses order using LIFO

D. List, because it sorts items automatically

Solution

1. Step 1: Understand the goal

   Reversing words means last word should come first, so order is reversed.

2. Step 2: Choose data structure behavior

   Stack uses Last-In-First-Out (LIFO), perfect for reversing order.

3. Step 3: Eliminate other options

   Queue keeps order (FIFO), Dictionary stores pairs unordered, List does not reverse automatically.

4. Final Answer:

   Stack, because it reverses order using LIFO -> Option C

5. Quick Check:

   Reverse order = Stack (LIFO) [OK]

Hint: Use Stack to reverse order with LIFO behavior [OK]

Common Mistakes:

• Choosing Queue for reversing
• Thinking List auto-sorts
• Using Dictionary for order
• Ignoring LIFO vs FIFO difference