Stack Basics: quick revision, 17 bites

Stack: The LIFO Principle

Last in, first out — always.

A **stack** is a linear data structure that follows the **LIFO** (Last-In, First-Out) principle. This means the most recently added element is the first one to be removed. Think of a stack of plates: you add and remove plates from the top only.

Takeaway. A stack's defining rule is LIFO: the last element pushed is the first element popped.

Core Stack Operations

The essential stack vocabulary.

Takeaway. Push and Pop are the primary mutators; Peek, isEmpty, and isFull are the primary accessors.

Push Operation: Step-by-Step

Adding to the top of the stack.

Takeaway. Push always adds to the top, updating the top pointer to the new element.

Pop Operation: Step-by-Step

Removing from the top of the stack.

Takeaway. Pop removes and returns the top element, then decrements the top pointer.

The Plate Dispenser Analogy

A real-world mental model.

Imagine a spring-loaded plate dispenser in a cafeteria. You can only take the plate from the top, and when you add a new plate, it goes on top of the existing ones. The last plate you put in is the first one you take out. This is exactly how a stack works.

Takeaway. The plate dispenser perfectly illustrates LIFO behavior in everyday life.

Stack vs. Queue

LIFO versus FIFO.

Takeaway. Stacks use LIFO, while queues use FIFO — a fundamental difference in data ordering.

Function Call Stack

How programs remember where to return.

When a program calls a function, the system uses a **call stack**. The current function's state (local variables, return address) is *pushed* onto the stack. When the function returns, that state is *popped* off, and the program resumes execution from the saved return address.

Takeaway. The call stack is a critical real-world use of stacks in every running program.

Undo/Redo in Text Editors

Reversing your last action.

Text editors use two stacks to implement **undo** and **redo** features. Every action is *pushed* onto the undo stack. Pressing 'Undo' *pops* the last action and *pushes* it onto the redo stack. Pressing 'Redo' reverses the process.

Takeaway. Undo/Redo functionality is a classic, user-facing application of the stack data structure.

Expression Evaluation & Syntax Parsing

Making sense of symbols and numbers.

Stacks are fundamental in compilers and calculators. They are used to **evaluate arithmetic expressions** (like converting infix to postfix) and to **check for balanced parentheses** and brackets in code. When an opening symbol is found, it's pushed; when a closing one is found, it's popped and matched.

Takeaway. Stacks enable compilers to parse syntax and evaluate expressions correctly.

Tracing a Stack Sequence

Watching the stack change.

Let's trace operations on an empty stack: `push(5)`, `push(10)`, `pop()`, `push(15)`, `peek()`.

Takeaway. Tracing operations clarifies how LIFO dictates the order of elements and results.

Stack Implementation in Python

A simple list-based stack.

Takeaway. Python lists provide a straightforward way to implement stack behavior using `append` and `pop`.

Forgetting Underflow/Overflow

Don't pop from an empty stack.

A common error is attempting a **pop** operation on an **empty** stack (underflow) or a **push** operation on a **full** stack (overflow). Always check `isEmpty()` before a pop and `isFull()` before a push in array-based implementations to avoid runtime errors.

Takeaway. Always validate stack state (empty/full) before performing pop or push operations.

Visualize for Exam Problems

Draw the stack to solve.

In exams, when asked to trace stack operations, **draw the stack** as a vertical list. Mark the top clearly. This visual approach helps avoid mistakes with LIFO ordering and makes it easier to determine the result of sequences of push and pop operations.

Takeaway. Visualizing the stack as a diagram is the most reliable strategy for solving trace problems.

Remembering LIFO

A simple mnemonic.

Remember **LIFO** as **L**ast **I**n, **F**irst **O**ut. A simple way to recall this is to think of a **LIFO** jacket: you put it on last, but you take it off first. The last item added is the first one removed.

Takeaway. Associating LIFO with a jacket helps cement the core stack principle.

Stacks in the CPU

Hardware uses stacks too.

The CPU itself uses a hardware stack for managing **interrupts** and **subroutine calls**. When an interrupt occurs, the CPU's current state is pushed onto the hardware stack, and when the interrupt handler finishes, the state is popped to resume the previous task.

Takeaway. Stacks are so fundamental that they are built directly into computer hardware.

Choosing Array vs. Linked List

Which implementation to use?

Use an **array-based** stack when the maximum size is known in advance and you need fast access. Use a **linked-list-based** stack when the size is dynamic and you want to avoid fixed-size limits. Both provide O(1) time for push and pop operations.

Takeaway. The choice between array and linked-list stacks depends on size predictability and memory constraints.

Stack Overflow in Recursion

Infinite recursion is dangerous.

If a recursive function lacks a proper **base case**, it will keep calling itself, pushing new frames onto the call stack until memory is exhausted. This results in a **stack overflow** error, crashing the program. Always ensure your recursive functions have a terminating condition.

Takeaway. Uncontrolled recursion causes stack overflow; always define a clear base case.