Stack Use Cases: Undo/Redo, Call Stack, and Expression Evaluation

Real-World Stack Applications

Stacks are not just a textbook concept — they power critical features in everyday software. Here are the most important real-world applications.

1. Function Call Stack

Every programming language uses a stack to manage function calls:

main() calls foo()
  foo() calls bar()
    bar() returns -> back to foo()
  foo() returns -> back to main()

Each function call pushes a stack frame containing local variables, return address, and parameters. When a function returns, its frame is popped. This is why infinite recursion causes a stack overflow — the call stack runs out of space.

2. Undo/Redo Systems

Text editors, drawing apps, and form builders use two stacks:

• Undo stack: Each action is pushed. Pressing undo pops the last action and pushes it onto the redo stack.
• Redo stack: Pressing redo pops from here and pushes back onto the undo stack.

Action: type "Hello"  -> undo: ["Hello"]     redo: []
Action: type " World" -> undo: ["Hello", " World"]  redo: []
Undo                  -> undo: ["Hello"]     redo: [" World"]
Redo                  -> undo: ["Hello", " World"]  redo: []

3. Browser Navigation

The back and forward buttons in web browsers use a stack-like model. Visiting a new page pushes the current URL onto the back stack. Clicking back pops from the back stack and pushes onto the forward stack.

4. Expression Evaluation

Compilers and calculators use stacks to evaluate mathematical expressions:

• Infix to postfix conversion: Uses an operator stack to reorder tokens according to precedence.
• Postfix evaluation: Pushes operands; when an operator is encountered, pops two operands, applies the operator, and pushes the result.

5. Balanced Parentheses Checking

One of the most classic stack problems:

Input: "({[]})"
- Push '('  -> stack: ['(']
- Push '{'  -> stack: ['(', '{']
- Push '['  -> stack: ['(', '{', '[']
- Pop for ']' matches '[' -> stack: ['(', '{']
- Pop for '}' matches '{' -> stack: ['(']
- Pop for ')' matches '(' -> stack: []
Result: Balanced!

6. Depth-First Search (DFS)

DFS on graphs and trees uses an explicit stack (or the call stack via recursion) to track which nodes to visit next. The LIFO property ensures that the algorithm explores as deep as possible before backtracking.