RDRYUSLOG DEV
Back to Blog
C#

C# Stack Peek: Inspect the Top Element Without Removing It

c# stack peek: Learn how to use the C# Stack<T>.Peek method to inspect the top element without removing it, including empty stack handling and performance.

C#Stack<T>PeekCollectionsData Structures
Illustration of a stack data structure with a pointer to the top element being inspected without removal.

c# stack peek requires a clear understanding of the core syntax, runtime behavior, and practical implementation patterns demonstrated in the examples below.

When you need to inspect the top element of a Stack<T> without removing it, the Peek method is the direct answer. In C#, stack peek is a common operation for algorithms that require lookahead on the most recent item. Unlike Pop, which returns and removes the top element, Peek leaves the stack unchanged. This distinction is crucial in scenarios where the decision to remove an element depends on its value or where the stack must remain intact for subsequent operations.

What Stack<T>.Peek Returns

The Peek method returns the object at the top of the stack without modifying the stack itself. For a Stack<T> containing reference types, it returns the reference; for value types, it returns a copy of the value. The method is O(1) because the stack internally tracks its top element.

var stack = new Stack<int>();
stack.Push(10);
stack.Push(20);
stack.Push(30);

int top = stack.Peek(); // returns 30
Console.WriteLine(top);  // 30
Console.WriteLine(stack.Count); // still 3

After calling Peek, the stack retains all its elements. This makes it useful for algorithms that need to examine the most recent item without committing to a removal.

Peek vs Pop: The Key Difference

Pop removes and returns the top element, while Peek only returns it. The choice between them affects the state of the stack and the flow of your algorithm.

var stack = new Stack<string>();
stack.Push("first");
stack.Push("second");

string peeked = stack.Peek(); // "second"
string popped = stack.Pop();  // "second"

Console.WriteLine(stack.Count); // 1 (only "first" remains)

Use Peek when you need to inspect the top item before deciding whether to pop it. For example, in expression evaluation, you might peek at an operator to determine precedence, then pop it only when the next operator has lower precedence. Using Pop prematurely would lose that information.

Handling Empty Stacks with Peek

Calling Peek on an empty Stack<T> throws an InvalidOperationException. This is a common runtime error that can be avoided by checking Count before peeking.

var stack = new Stack<int>();

if (stack.Count > 0)
{
    int value = stack.Peek();
}
else
{
    // handle empty case
}

For .NET Core 2.0 and later, the TryPeek method provides a safer alternative. It returns a bool indicating success and outputs the top element via an out parameter, avoiding the exception entirely.

var stack = new Stack<int>();

if (stack.TryPeek(out int value))
{
    Console.WriteLine(value);
}
else
{
    Console.WriteLine("Stack is empty");
}

TryPeek is especially useful in multithreaded scenarios where the stack might be modified between a count check and a peek, though Stack<T> itself is not thread-safe. For concurrent access, consider using ConcurrentStack<T> which offers TryPeek as well.

When to Use Peek Instead of Pop

Peek is the right choice whenever you need to look ahead without altering the stack. Common use cases include:

  • Parsing nested structures: When matching parentheses or brackets, you peek to see if the top matches the closing character before popping.
  • Undo/redo systems: You might peek at the last action to decide whether to merge it with a new action, then pop only if needed.
  • Backtracking algorithms: In depth-first search, you may peek at the current path's last node to decide the next move without immediately removing it.
  • State machines: When the next state depends on the current top of the stack, peeking lets you inspect without losing the ability to revert.

In contrast, use Pop when you are certain the top element is no longer needed. Overusing Pop can lead to accidental data loss if the logic later requires the removed element.

Performance and Memory Characteristics

Peek is an O(1) operation. It does not allocate new memory for the returned value when the stack holds value types because the value is copied by value. For reference types, it simply returns the reference, so no new object is created. This makes Peek a low-overhead operation suitable for tight loops.

// Repeated peeking in a loop is cheap
while (stack.Count > 0)
{
    var current = stack.Peek();
    // process current without removing it
    if (ShouldRemove(current))
    {
        stack.Pop();
    }
    else
    {
        break;
    }
}

The absence of allocation also means Peek does not contribute to garbage collection pressure. However, be aware that Stack<T> stores elements in an internal array. When the stack grows, it reallocates and copies elements. This is unrelated to Peek itself but affects the overall memory profile of the stack.

Common Mistakes and Edge Cases

A frequent mistake is assuming Peek removes the element. This leads to infinite loops when the code expects the stack to shrink after a peek. Another issue is calling Peek without checking for an empty stack, which throws an exception that may be caught too broadly.

// Infinite loop: Peek does not remove
while (stack.Count > 0)
{
    var item = stack.Peek();
    // forgot to Pop
}

Edge cases also arise with value types that have default values. If a stack contains 0 or null (for nullable value types), Peek will return that value, which is valid. The TryPeek method distinguishes between a successful peek and an empty stack, so you don't have to rely on sentinel values.

For custom types, Peek returns a reference to the existing object. Mutating that object modifies the stack's top element, which may be intended or a source of subtle bugs if you assumed a copy. If you need a defensive copy, you must create one manually.

Alternatives: Custom Stack or Queue

If you frequently need to inspect the top element without removal, Stack<T> is the natural choice. But consider LinkedList<T> or a custom implementation if you need additional operations like peeking at the second element. The .NET Stack<T> only exposes the top; there is no built-in way to peek at lower elements without popping them. In such cases, you might maintain a separate list or use a different data structure.

For LIFO scenarios where you also need to access the bottom or middle elements, a List<T> with explicit Add and RemoveAt can provide more flexibility, though it sacrifices the O(1) top access guarantee if you always operate on the last element. The tradeoff is between simplicity and performance. For most stack use cases, Peek and Pop are sufficient.

When working with concurrent code, ConcurrentStack<T> provides thread-safe TryPeek and TryPop methods. Its TryPeek is atomic and does not require a separate count check, which is safer in producer-consumer scenarios.

Understanding the exact behavior of Peek—what it returns, when it throws, and how it differs from Pop—prevents common bugs and lets you write more predictable code. The method is simple, but its correct usage is foundational for many algorithms that rely on stack-based lookahead.

c# stack peek: Practical Usage and Code Examples | RYUSLOG DEV