Stack (LIFO) Visualization — Step by Step

One open end

A stack is a list you are only allowed to touch at one end, called the top. That single restriction creates the LIFO invariant: whatever went in last must come out first, because it is sitting on top of everything else. Picture a stack of plates — you add to the top and take from the top, and the plate at the bottom stays put until every plate above it is gone. Internally all you need is a container plus a top pointer (or, with an array backing, just the array length), which is why every stack operation runs in O(1).

Push and pop, traced

Start empty and push(5), push(2), push(8). The stack is now [5, 2, 8] with 8 on top — index 2 in the visualizer. Call pop() and you get 8 back, not 5: last in, first out. Pop again and you get 2, leaving [5]. Notice that pop both *returns* the top value and *removes* it — the two are one atomic operation. The demo in the visualizer above runs the full lifecycle: it pushes every value, then pops until the stack is empty, so you can watch the exit order exactly mirror the entry order.

Peek and underflow

Sometimes you want to look without touching. peek() (also called *top*) returns the top element but leaves the stack unchanged — useful when the next action depends on what is on top, like checking whether the operator on the stack has higher precedence before deciding to pop it. The failure mode to guard against is underflow: calling pop or peek on an empty stack. Real implementations either throw an error or return a sentinel like undefined; either way, checking isEmpty() first is the idiom. There is no way to read the bottom or middle without popping everything above it — that is the contract.

The call stack: the stack you use every day

Every running program uses a stack constantly. When a function is called, the runtime pushes a frame holding its local variables and return address; when the function returns, that frame is popped and execution resumes underneath. Nested calls stack up frames; recursion stacks up one frame per level. This is why unbounded recursion crashes with a *stack overflow* — the frames exhaust the memory reserved for the call stack — and why a recursive algorithm can always be rewritten iteratively by managing an explicit stack yourself.

Where stacks show up

Stacks appear anywhere the most recent thing matters most. Undo history pushes each edit and pops to revert. The browser back button pops the page you most recently visited. Compilers evaluate expressions and match brackets with stacks: push every (, pop on every ), and a clean empty stack at the end means the string is balanced. And depth-first search is literally "graph traversal with a stack" — replace the stack with a queue and the exact same code becomes breadth-first search.

JavaScript

class Stack {
  #items = [];

  push(value) {
    this.#items.push(value);
  }

  pop() {
    if (this.isEmpty()) throw new Error('Stack underflow');
    return this.#items.pop();
  }

  peek() {
    return this.#items[this.#items.length - 1];
  }

  isEmpty() {
    return this.#items.length === 0;
  }

  get size() {
    return this.#items.length;
  }
}

Python

class Stack:
    def __init__(self):
        self._items = []

    def push(self, value):
        self._items.append(value)

    def pop(self):
        if self.is_empty():
            raise IndexError("stack underflow")
        return self._items.pop()

    def peek(self):
        return self._items[-1] if self._items else None

    def is_empty(self):
        return len(self._items) == 0

    def __len__(self):
        return len(self._items)

Java

import java.util.ArrayList;

public class Stack<T> {
    private final ArrayList<T> items = new ArrayList<>();

    public void push(T value) {
        items.add(value);
    }

    public T pop() {
        if (isEmpty()) throw new IllegalStateException("Stack underflow");
        return items.remove(items.size() - 1);
    }

    public T peek() {
        if (isEmpty()) throw new IllegalStateException("Stack is empty");
        return items.get(items.size() - 1);
    }

    public boolean isEmpty() {
        return items.isEmpty();
    }
}