Stacks & Queues in C# – Stack<T>, Queue<T>

Introduction

In the world of computer science, stacks and queues are fundamental data structures that every developer should understand. Whether you're managing function calls, handling events, or processing tasks, Stack<T> and Queue<T> in C# provide efficient and reliable ways to organize data.

C#’s Stack<T> and Queue<T> are both generic collections found in the System.Collections.Generic namespace. While Stack works on a Last-In-First-Out (LIFO) principle, Queue operates on a First-In-First-Out (FIFO) model. Each is optimized for specific scenarios and use cases.

What is Stack<T>?

Stack<T> represents a simple collection where the last item added is the first to be removed—like stacking books or trays. It’s ideal for tasks like undo operations, parsing expressions, and managing backtracking logic.

Basic Operations:

• Push: Add an item to the top of the stack.
• Pop: Remove and return the item from the top.
• Peek: Return the item from the top without removing it.

Stack<string> history = new Stack<string>();
history.Push("Page 1");
history.Push("Page 2");
history.Push("Page 3");

Console.WriteLine(history.Peek()); // Output: Page 3
Console.WriteLine(history.Pop());  // Output: Page 3
Console.WriteLine(history.Pop());  // Output: Page 2

What is Queue<T>?

Queue<T> is a collection where the first item added is the first to be removed. It mimics a real-world queue, such as people waiting in line. It’s widely used in messaging systems, print spoolers, and scheduling algorithms.

Basic Operations:

• Enqueue: Add an item to the end of the queue.
• Dequeue: Remove and return the item from the front.
• Peek: View the item at the front without removing it.

Queue<string> requests = new Queue<string>();
requests.Enqueue("Request A");
requests.Enqueue("Request B");
requests.Enqueue("Request C");

Console.WriteLine(requests.Peek());    // Output: Request A
Console.WriteLine(requests.Dequeue()); // Output: Request A
Console.WriteLine(requests.Dequeue()); // Output: Request B

Stack vs Queue: Key Differences

While both Stack<T> and Queue<T> are linear collections, they behave in fundamentally different ways due to their access order:

Feature	Stack<T>	Queue<T>
Access Pattern	LIFO (Last-In-First-Out)	FIFO (First-In-First-Out)
Use Case	Undo, Backtracking	Task Processing, Messaging
Primary Methods	Push, Pop, Peek	Enqueue, Dequeue, Peek
Thread-Safety	Not thread-safe by default	Not thread-safe by default

Real-World Use Cases

Stack<T> Use Cases

• Browser navigation (back/forward pages)
• Undo/redo in text editors
• Parsing nested structures like parentheses
• Depth-first search (DFS) in graphs

Queue<T> Use Cases

• Print job scheduling
• Task queues in multi-threaded apps
• Breadth-first search (BFS) in graphs
• Message or event processing

Performance Comparison

Both Stack<T> and Queue<T> are implemented using internal arrays and offer efficient O(1) operations for insertion and removal.

• Push/Pop: Constant time in Stack.
• Enqueue/Dequeue: Constant time in Queue.
• Memory: Both use dynamic resizing, which may allocate extra memory internally for growth.

Example: Measuring Performance

Stack<int> stack = new Stack<int>();
Queue<int> queue = new Queue<int>();

for (int i = 0; i < 1000000; i++) {
    stack.Push(i);
    queue.Enqueue(i);
}

while (stack.Count > 0) {
    var item = stack.Pop();
}

while (queue.Count > 0) {
    var item = queue.Dequeue();
}

Both perform very efficiently in large-scale operations, making them ideal for high-performance applications.

When to Use Stack vs Queue

• Use Stack<T> when the most recently added item needs to be accessed first.
• Use Queue<T> when you need to process items in the order they were added.
• If order doesn’t matter, and you just need to store data, consider using List<T> or LinkedList<T>.

Best Practices for Using Stack<T> and Queue<T>

• Always check Count before calling Pop or Dequeue to avoid exceptions.
• Use Peek if you only need to read the next item without removing it.
• Clear the collection after use to free up memory if you're done processing.
• Consider ConcurrentStack<T> and ConcurrentQueue<T> for thread-safe operations in multi-threaded environments.

// Safe Dequeue Example
if (queue.Count > 0)
{
    var item = queue.Dequeue();
    Console.WriteLine(item);
}

Conclusion

Stack<T> and Queue<T> are essential C# collections that provide efficient, organized ways to manage data based on access patterns. Understanding the LIFO vs. FIFO behavior will help you choose the right tool for the job.

• Use Stack<T> for tasks like undo, backtracking, and nested parsing.
• Use Queue<T> for orderly processing, task scheduling, and real-time data flows.

By mastering these data structures, you build a strong foundation in efficient data handling, memory management, and scalable application development.

FAQs

1. Are Stack<T> and Queue<T> thread-safe?

No, use ConcurrentStack<T> and ConcurrentQueue<T> in multi-threaded scenarios.

2. What happens if I call Pop or Dequeue on an empty collection?

An InvalidOperationException will be thrown. Always check Count first.

3. Can I convert a Stack or Queue to an array?

Yes, use the .ToArray() method to convert either to an array.

4. What is the default capacity of Stack<T> and Queue<T>?

Both start with a small default size and resize dynamically as items are added.

5. Can Stack and Queue store reference types?

Yes, both support storing reference and value types. You can use generics like Stack<string> or Queue<MyClass>.