C# provides two essential data structures for managing collections: Queue and Stack. These structures offer unique ways to organize and access data, each with its own specific use cases.

Queue in C#

A Queue is a first-in-first-out (FIFO) data structure. It's like a line of people waiting for a service - the first person to join the queue is the first to be served.

Key Queue Operations

Enqueue: Adds an element to the end of the queue
Dequeue: Removes and returns the element at the front of the queue
Peek: Returns the element at the front without removing it

Queue Example


using System;
using System.Collections.Generic;

Queue<string> customerQueue = new Queue<string>();

customerQueue.Enqueue("Alice");
customerQueue.Enqueue("Bob");
customerQueue.Enqueue("Charlie");

Console.WriteLine(customerQueue.Dequeue());  // Output: Alice
Console.WriteLine(customerQueue.Peek());     // Output: Bob

Stack in C#

A Stack is a last-in-first-out (LIFO) data structure. Think of it as a stack of plates - you add and remove plates from the top.

Key Stack Operations

Push: Adds an element to the top of the stack
Pop: Removes and returns the element from the top of the stack
Peek: Returns the top element without removing it

Stack Example


using System;
using System.Collections.Generic;

Stack<int> numberStack = new Stack<int>();

numberStack.Push(1);
numberStack.Push(2);
numberStack.Push(3);

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

Choosing Between Queue and Stack

The choice between Queue and Stack depends on your specific use case:

Use a Queue when you need to process items in the order they were added (e.g., print job queues, breadth-first search algorithms).
Use a Stack when you need to process items in reverse order or implement undo functionality (e.g., backtracking algorithms, browser history).

Performance Considerations

Both Queue and Stack in C# offer O(1) time complexity for their core operations (Enqueue/Dequeue for Queue, Push/Pop for Stack). This makes them efficient choices for managing collections with specific access patterns.

Thread Safety

The standard Queue and Stack implementations in C# are not thread-safe. For concurrent scenarios, consider using C# Concurrent Collections like ConcurrentQueue and ConcurrentStack.

Related Concepts

To further enhance your understanding of data structures in C#, explore these related topics:

By mastering Queue and Stack, you'll have powerful tools at your disposal for solving various programming challenges efficiently.