Stack applications
A stack’s LIFO rule shows up everywhere: inside runtimes and compilers, in graph and string algorithms, and in products people use daily. This page splits examples into computer science uses (how we teach and implement algorithms) and real-life uses (what users experience). Later lessons in this track implement several of these ideas in C.
- Computer science applications — runtimes, parsing, graphs, expressions, backtracking
- Real-life applications — undo, history, nested workflows people recognize
1) Computer science applications
These are classic reasons stacks appear in courses, interviews, and systems code. Many pair naturally with recursion (the language runtime keeps its own stack of activation records).
| Application | How a stack is used | In this tutorial |
|---|---|---|
| Call stack & recursion | Each function call pushes an activation frame; return pops it. Iterative versions of recursive algorithms often use an explicit stack to simulate that behavior. |
Stack and recursion |
| Expression handling | Converting infix to postfix, evaluating postfix, and building expression trees use stacks to hold operators or operands in the right order. | Infix to postfix · Postfix evaluation · Expression tree |
| Bracket & delimiter matching | Scan left to right: push opening symbols, pop and compare on closers. One stack tracks nesting depth. | Brackets validation |
| Depth-first search (DFS) | Explore deep before wide: an explicit stack (or recursion) drives DFS on graphs and trees. | — |
| Syntax parsing | Compilers and interpreters use stack-based parsers (e.g. shift–reduce) to match nested structure in source code. | — |
| Backtracking | Push a choice or state; on failure, pop and try the next branch (mazes, Sudoku, combinatorial search). | — |
| Monotonic stack | Keep elements in increasing or decreasing order to solve “next greater element” and similar problems in O(n) time. | Monotonic stack |
2) Real-life applications
These mirror the same LIFO idea: the most recent action or item is the one you undo, revisit, or finish first.
| Application | How it maps to LIFO | In this tutorial |
|---|---|---|
| Undo / redo | Editors store operations on an undo stack; redo often uses a second stack of undone actions. | Stack for undo / redo |
| Browser back & forward | Navigating can push the current page; Back pops to the previous URL. A forward stack is a common partner. | Stack for browser history |
| Reverse a string | Push characters in reading order, then pop them into a new buffer—LIFO turns the last in into the first out. | Stack for string reverse |
| Nested dialogs & wizards | Closing the top surface before the one below matches popping the current UI context off a stack. | — |
| Physical analogies | Plates, cafeteria trays, or books: you add and remove only from the top—the everyday picture of a stack. | — |
| Tasks & notifications | “Most recent first” lists and alert stacks show the latest item on top, matching user expectations for clearing or reviewing. | — |
In code, these features may combine stacks with queues, lists, or persistent storage; the abstract stack still explains the LIFO slice of the design.
Key takeaway
If the problem needs last-in, first-out access—nesting, reversal, deep search, or “go back to what I did last”—a stack is the right mental model. The next lesson makes the ADT concrete with operations and invariants before you implement with arrays or linked lists in C.
Next up: Stack operations · Stack using array · Introduction to Stack