COURSE: DATA STRUCTURES & ALGORITHMS
SECTION 04 // STACKS
C++ DATA STRUCTURES•SPRING
Section 4 — Data Structures
Stacks & LIFO
One open end, one rule: the last element in is the first element out. Build the same contract twice — once on a fixed array, once on a chain of nodes.
WHAT WE'LL COVER16 SLIDES
- 01Cover
- 02What Is a Stack?
- 03The LIFO Sequence
- 04std::stack
- 05Array Structure
- 06Push
- 07Pop & Peek
- 08Display & Run
- 09Overflow & Underflow
- 10Linked Structure
- 11Pointer Push & Pop
- 12Peek & Display
- 13Integer Stack Run
- 14String Stack Run
- 15Array vs. Linked
- 16Key Takeaways
C++ · Stack · LIFO · Array · Linked List
SECTION 04: FOUNDATIONS
SLIDE 02 // WHAT IS A STACK?
LIFO
Foundations
What Is a Stack?
A linear collection with one open end: everything goes in and comes out at the top, so the newest element leaves first.
RULELast In, First Out (LIFO).
PUSHAdds an element at the top.
POPRemoves the element at the top.
TOPReads the top without removing it.
PROPERTYWHAT IT MEANS
Newest firstThe last element in is the first one served.
Single endPush and pop use the top — never the base or middle.
Older buriedOlder elements wait until every newer one above them leaves.
THE PLATE STACK — LIVELOOPING · PUSH AND POP AT THE TOP
▲ TOP · OPEN ENDPUSH / POP
[4]—
[3]—
[2]30TOP
[1]20
[0]10
▼ CLOSED BASEINDEX 0
IN STACK · 310, 20 and 30 are stacked — 30 sits on top.
LIKE PLATESPlates go on the top and come off the top. That is the whole rule.
ONE OPEN ENDBOTH OPERATIONS USE THE SAME DOOR
Push (place on top)⇄Top of stack⇄Pop (take from top)
SECTION 04: FOUNDATIONS
SLIDE 03 // THE LIFO SEQUENCE
PUSH ×3 · POP ×3
LIFO Visualization
The LIFO Sequence
Three pushes fill the stack; three pops empty it. The exit order is the entry order, reversed.
3 PUSHES
Each value lands on the one before it. After three, 30 is on top.
10 → 20 → 30
FIRST POP
30 leaves first. 20 becomes the new top.
pop() → 30
SECOND POP
20 leaves; the element beneath it is exposed.
pop() → 20
THIRD POP
10 leaves last, and the stack is empty.
pop() → 10
READ IT BACKWARDS30 20 10 is the push order 10 20 30, reversed.
SIX MOVES — LIVECLICK A STEP OR PLAY
▲ TOP · OPEN ENDPUSH / POP
[2]30TOP
[1]20
[0]10
▼ CLOSED BASEINDEX 0
STEP 3 / 6PUSH 30
30 is the newest element, so 30 is the top. Three plates, one open end.
RETURNED — LIFO ORDER
302010nothing has left yet
PUSH · PUSH 30
NO REORDERINGElements never move. Only the top changes — and that one leaves next.
SECTION 04: EXAMPLE 1
SLIDE 04 // THE BUILT-IN STACK
std::stack<int>
Example 1 — Standard Library
The Built-in Stack
The program pushes 10, 20 and 30, reads the top, then drains the stack with top() and pop().
INCLUDE
Import the STL container.
#include <stack>
CREATE
Start with an empty stack of ints.
stack<int> s;
PUSH
Each call lands on the current top.
s.push(10); s.push(20); s.push(30);
READ
Returns 30 without removing it.
s.top()
DRAIN
Print, pop, repeat: 30 20 10.
while (!s.empty())
LIVE STACK — std::stack<int>top → 30 · 3 ELEMENTS
▲ TOP · OPEN ENDPUSH / POP
[2]30TOP
[1]20
[0]10
▼ CLOSED BASEINDEX 0
STL_STACK.CPPEXAMPLE 1 · VERBATIM
#include <iostream>#include <stack>using namespace std;int main() { // Using C++ built-in stack to demonstrate LIFO stack<int> s; // Push elements s.push(10); s.push(20); s.push(30); cout << "Top element: " << s.top() << endl; // 30 // Pop elements (Last In, First Out) cout << "Popping elements:" << endl; while (!s.empty()) { cout << s.top() << " "; s.pop(); } cout << endl; // 30 20 10 return 0;}
CONSOLE OUTPUTLIVE
Top element: 30
s.top() reads arr[top] — 30 — without changing the stack. Reading is not removing.
STEP 4 / 8
SECTION 04: ARRAY IMPLEMENTATION
SLIDE 05 // THE STRUCTURE
MAX•arr[MAX]•top
Example 2 — Array-Backed
A Stack in an Array
Five cells, one integer: top is the index of the highest written cell, and -1 means the stack is empty.
CAPACITYMAX = 5
STORAGEint arr[MAX];
STATEint top;
EMPTYtop == -1
FULLtop == MAX - 1
STATEMEANING
top = -1Empty — no cell belongs to the stack.
top = 0One element in
arr[0].top = MAX - 1All five cells are used; the next push overflows.
STACK_ARRAY_HEADER.CPPEXAMPLE 2 · STATE & GUARDS
const int MAX = 5; // Maximum size of the stackclass Stack {private: int arr[MAX]; // Array to store stack elements int top; // Index of the top elementpublic: // Constructor Stack() { top = -1; // Stack is initially empty } // Check if stack is full bool isFull() { return (top == MAX - 1); } // Check if stack is empty bool isEmpty() { return (top == -1); }
SECTION 04: ARRAY IMPLEMENTATION
SLIDE 06 // PUSH
top++
Array Operation
Push — One Cell Higher
push() guards capacity, moves top up, and writes into arr[top]. Nothing else moves.
GUARDif (isFull())
OVERFLOW"Stack Overflow! Cannot push " << value
MOVEtop++
WRITEarr[top] = value;
CONFIRMvalue << " pushed into stack."
PUSH 10
10 lands in cell 0; top becomes 0.
top 0 · arr[0] = 10
PUSH 20
20 is written above 10; top becomes 1.
top 1 · arr[1] = 20
PUSH 30
30 is written above 20; top becomes 2.
top 2 · arr[2] = 30
PUSH_METHOD.CPPEXAMPLE 2 · push(int value)
// Push operation void push(int value) { if (isFull()) { cout << "Stack Overflow! Cannot push " << value << endl; } else { top++; arr[top] = value; cout << value << " pushed into stack." << endl; } }
AFTER THREE PUSHEStop [2] · 3 OF 5 CELLS IN USE
top [2]
[0]10
[1]20
[2]30
[3]—
[4]—
THE MOVING PARTOnly the index changes. The cells that are already written keep their addresses and their values.
SECTION 04: ARRAY IMPLEMENTATION
SLIDE 07 // POP & PEEK
top-- / top unchanged
Array Operations
Pop and Peek
Both guard with isEmpty() and read arr[top]. Then pop() decrements top; peek() stops.
STEPPOP VS. PEEK
1. GuardBoth check
isEmpty() before reading.2. If emptyEach prints its own message; neither reads.
3. OtherwiseBoth read
arr[top]; only pop() runs top--.4. Afterwards
pop() shrinks the stack; peek() changes nothing.AFTER pop() — TOP MOVED, CELL DID NOTtop [1] · 30 STILL LIVES IN arr[2]
top [1]
[0]10
[1]20
[2]30
[3]—
[4]—
POP_AND_PEEK.CPPEXAMPLE 2 · pop() & peek()
// Pop operation void pop() { if (isEmpty()) { cout << "Stack Underflow! Cannot pop." << endl; } else { cout << arr[top] << " popped from stack." << endl; top--; } } // Peek operation: get top element without removing void peek() { if (isEmpty()) { cout << "Stack is empty." << endl; } else { cout << "Top element is: " << arr[top] << endl; } }
SECTION 04: ARRAY IMPLEMENTATION
SLIDE 08 // DISPLAY & THE FIRST RUN
for (i = top; i >= 0; i--)
Traversal & Execution
Display and the First Run
display() walks from top down to 0, newest first. The first run pushes three values, displays, peeks, then pops twice.
STEP 1
Empty stack: print a message and stop.
isEmpty()
STEP 2
Print the heading once.
"Stack elements (top to bottom): "
STEP 3
Walk from the top down to index 0.
for (int i = top; i >= 0; i--)
STEP 4
Print each cell: 30, 20, 10.
cout << arr[i] << " ";
IN main()
Peek reads 30; two pops leave 10.
s.display(); s.peek(); s.pop(); s.pop();
ARRAY STACK — LIVEtop [2] · 3 OF 5 CELLS
top [2]
[0]10
[1]20
[2]30
[3]—
[4]—
STACK — TOP TO BASE30 → 20 → 10
STACK_ARRAY_RUN.CPPEXAMPLE 2 · display() + main()
void display() { if (isEmpty()) { cout << "Stack is empty." << endl; } else { cout << "Stack elements (top to bottom): "; for (int i = top; i >= 0; i--) { cout << arr[i] << " "; } cout << endl; }}int main() { Stack s; s.push(10); s.push(20); s.push(30); s.display(); s.peek(); s.pop(); s.pop(); s.display(); return 0;}
CONSOLE OUTPUTLIVE
10 pushed into stack.20 pushed into stack.30 pushed into stack.Stack elements (top to bottom): 30 20 10
display() starts at i = top and walks down to 0: 30, then 20, then 10.
STEP 4 / 8
SECTION 04: ROBUSTNESS
SLIDE 09 // OVERFLOW & UNDERFLOW
isFull() · isEmpty()
Boundary Conditions
Overflow and Underflow
Five cells means the sixth push must be refused; an empty stack must refuse pop(). Both guards print and change nothing.
OVERFLOWtop == MAX - 1
REFUSAL"Stack Overflow! Cannot push " << value
UNDERFLOWtop == -1
REFUSAL"Stack Underflow! Cannot pop."
THE TEST10 remains; 40–70 fill cells 1–4.
THE LIMITS — LIVEtop [4] · 5 OF 5 CELLS
top [4]
[0]10
[1]40
[2]50
[3]60
[4]70
STACK — TOP TO BASE70 → 60 → 50 → 40 → 10
BOUNDARY_TESTS.CPPEXAMPLE 2 · OVERFLOW & UNDERFLOW
cout << "\n=== Stack Overflow Test ===" << endl;s.push(40);s.push(50);s.push(60);s.push(70);s.push(80); // Overflow (MAX = 5, but we only have 3 after pops)s.push(90); // Overflowcout << "\n=== Stack Underflow Test ===" << endl;s.pop(); s.pop(); s.pop(); s.pop(); s.pop(); // Pop alls.pop(); // Underflow
CONSOLE OUTPUTLIVE
=== Stack Overflow Test ===40 pushed into stack.50 pushed into stack.60 pushed into stack.70 pushed into stack.Stack Overflow! Cannot push 80
push(80) asks for a sixth cell in a five-cell array. isFull() refuses it and nothing is written.
STEP 5 / 13
SECTION 04: LINKED-LIST IMPLEMENTATION
SLIDE 10 // NODES & TOP
Node<T>* top
Example 3 — Linked Stack
A Stack of Nodes
No array, no MAX. Each node holds a value and a pointer; the stack is one pointer to the first node.
NODET data; Node* next;
TOPNode<T>* top; → the first node
EMPTYtop == nullptr
ALLOCATEnew Node<T>(value)
FREEdelete temp
1. NODE
A value plus the address below it.
data + next
2. TOP
One pointer is the whole stack.
Node<T>* top
3. END
The last node marks the base.
next == nullptr
NODE_STRUCTURE.CPPEXAMPLE 3 · Node TEMPLATE
// Node structuretemplate <class T>class Node {public: T data; Node* next; Node(T value) { data = value; next = nullptr; }};
THREE NODES, ONE TOPtop → 30 → 20 → 10 → nullptr
top
data30next•
data20next•
data10next•
SECTION 04: LINKED-LIST IMPLEMENTATION
SLIDE 11 // POINTER PUSH & POP
new•link•delete
Linked Operations
Push and Pop
push() allocates a node at the head; pop() steps top forward and deletes the node behind it.
OPERATIONWHAT IT DOESCODE
ConstructorStart with no nodes.
top = nullptr;isEmptyNo node to read.
top == nullptrPushAllocate the node.
new Node<T>(value)LinkPoint it at the old top.
newNode->next = top;UpdateMake it the new top.
top = newNode;PopSave the old top, advance.
temp = top; top = top->next;DeleteFree the node that left.
delete temp;DestructorDrain the chain.
while (!isEmpty()) pop();LINKED STACK — LIVE POINTER TRACEtop → 30 · 3 NODES
top
data30next•
data20next•
data10next•
STACK_LINKED_LIST.CPPEXAMPLE 3 · push & pop
void push(T value) { Node<T>* newNode = new Node<T>(value); newNode->next = top; // New node points to old top top = newNode; // Update top cout << value << " pushed into stack." << endl;}void pop() { if (isEmpty()) { cout << "Stack Underflow! Cannot pop." << endl; } else { cout << top->data << " popped from stack." << endl; Node<T>* temp = top; top = top->next; delete temp; }}
CONSOLE OUTPUTLIVE
10 pushed into stack.20 pushed into stack.30 pushed into stack.30 popped from stack.
pop() prints top->data (30), then saves the same pointer in temp. Top has not moved yet.
STEP 7 / 9
SECTION 04: LINKED-LIST IMPLEMENTATION
SLIDE 12 // PEEK & DISPLAY
temp = top
Traversal
Peek and Display
peek() reads top->data in one line. display() walks a temporary pointer from the top to nullptr.
STEP 1
Both methods start with the same guard.
if (isEmpty())
STEP 2
peek() prints the top value; top never moves.
top->data
STEP 3
display() copies top into temp.
Node<T>* temp = top;
STEP 4
Walk until the pointer falls off the end.
while (temp != nullptr)
STEP 5
Print, then advance. The chain is only read.
temp = temp->next;
LINKED STACK — TRAVERSALtemp → 30 · top → 30
top
data30next•
tempdata20next•
data10next•
LINKED_PEEK_DISPLAY.CPPEXAMPLE 3 · peek & display
void peek() { if (isEmpty()) { cout << "Stack is empty." << endl; } else { cout << "Top element is: " << top->data << endl; }}void display() { if (isEmpty()) { cout << "Stack is empty." << endl; } else { cout << "Stack elements (top to bottom): "; Node<T>* temp = top; while (temp != nullptr) { cout << temp->data << " "; temp = temp->next; } cout << endl; }}
CONSOLE OUTPUTLIVE
Top element is: 30Stack elements (top to bottom): 30
The while condition is true (temp != nullptr), so temp->data is printed: 30.
STEP 2 / 7
SECTION 04: EXAMPLE 3
SLIDE 13 // INTEGER STACK RUN
Stack<int>
Execution Trace
The Integer Stack
The first half of main() runs the integer stack end to end, in source order.
main() — INTEGER HALF8 CALLS · FINAL: 20 10
| Call | Stack after | Output |
|---|---|---|
| Stack<int> s | (empty) | — |
| push(10) | 10 | 10 pushed into stack. |
| push(20) | 20 10 | 20 pushed into stack. |
| push(30) | 30 20 10 | 30 pushed into stack. |
| display() | 30 20 10 | Stack elements (top to bottom): 30 20 10 |
| peek() | unchanged | Top element is: 30 |
| pop() | 20 10 | 30 popped from stack. |
| display() | 20 10 | Stack elements (top to bottom): 20 10 |
NOT OVER YET20 and 10 are still stacked when
main() moves on; the destructor drains them.EXAMPLE 3 — INTEGER STACK IN MAIN()top → 30 · 3 NODES
top
data30next•
data20next•
data10next•
INTEGER_STACK_MAIN.CPPEXAMPLE 3 · main()
int main() { Stack<int> s; cout << "=== Integer Stack ===" << endl; s.push(10); s.push(20); s.push(30); s.display(); // 30 20 10 s.peek(); // 30 s.pop(); // 30 s.display(); // 20 10
PROGRAM OUTPUTLIVE
=== Integer Stack ===10 pushed into stack.20 pushed into stack.30 pushed into stack.Stack elements (top to bottom): 30 20 10
display() walks temp from 30 to 10 and prints each data field: 30 20 10.
STEP 5 / 8
SECTION 04: EXAMPLE 3
SLIDE 14 // STRING STACK RUN
Stack<string>
Generic Stack
The String Stack
Nothing in Stack<T> mentions int except the type argument. The same code compiles for strings.
TEMPLATEtemplate <class T>
INTStack<int> s;
STRINGStack<string> strStack;
SAME CODEpush · peek · pop · display
WHAT CHANGESWHAT DOES NOT
Payload
int becomes string.Everything else
top, push, pop, peek and display are shared.THE DESTRUCTOR PRINTS
~Stack() pops until the chain is empty. The transcript stops early; the code does not.Stack<string> — LIVEtop → Carol · 3 NODES
▲ TOP · OPEN ENDPUSH / POP
[2]CarolTOP
[1]Bob
[0]Alice
▼ CLOSED BASEINDEX 0
STRING_STACK.CPPEXAMPLE 3 · main() + ~Stack()
cout << "\n=== String Stack ===" << endl;Stack<string> strStack;strStack.push("Alice");strStack.push("Bob");strStack.push("Carol");strStack.display(); // Carol Bob Alice// main() returns: strStack is destroyed~Stack() { while (!isEmpty()) { pop(); }}
PROGRAM OUTPUTLIVE
=== String Stack ===Alice pushed into stack.Bob pushed into stack.Carol pushed into stack.Stack elements (top to bottom): Carol Bob Alice
display() walks the same top-to-bottom path and prints Carol Bob Alice.
STEP 4 / 8
SECTION 04: SYNTHESIS
SLIDE 15 // ARRAY VS. LINKED LIST
TWO STORAGES, ONE CONTRACT
Comparison
Two Ways to Be a Stack
ASPECTARRAY STACKLINKED STACK
StorageOne fixed array,
int arr[MAX]Nodes on the heap, Node<T>*CapacityFixed at compile time (MAX = 5)Grows and shrinks with every call
TopInteger index,
int topNode pointer, Node<T>* topEmpty
top == -1top == nullptrFull
top == MAX - 1No full state existsOverflowThe sixth push is refusedCannot overflow — only run out of memory
CleanupAutomatic with the array's lifetime
~Stack() pops and deletes each nodeTypesHard-coded to
intAny T — int, string, and so onTHE SAME THREE VALUES — ARRAYINDEXED CELLS · top [2]
top [2]
[0]10
[1]20
[2]30
[3]—
[4]—
THE SAME THREE VALUES — LINKEDNODES AND POINTERS · top → 30
top
data30next•
data20next•
data10next•
SAME CONTRACTpush, pop, peek and display behave identically in both. Only the storage, the capacity and the cleanup change.
SECTION 04: SYNTHESIS
SLIDE 16 // KEY TAKEAWAYS
SUMMARY
Lesson Synthesis
Key Takeaways
PRINCIPLEREMEMBER
LIFOLast in, first out.
One endPush and pop use only the top.
PeekRead without removing.
Array
int top over arr[MAX]; guard -1 and MAX - 1.Linked
Node<T>* top; push and pop at the head.Destructor
~Stack() drains the chain.TemplateOne implementation, any type.
ContractStorage changes; behavior does not.
THE ONE-SENTENCE VERSIONSECTION 04
IDEAIN ONE LINE
The ruleAdd at the top, remove from the top. Everything else is storage.
The trade-offThe array is fixed and compact; the linked list is dynamic and pointer-based.
THREE ORIGINAL PROGRAMSEXAMPLE 1 · EXAMPLE 2 · EXAMPLE 3
PROGRAMSOURCE FILE
Example 1
stl-stack.cppExample 2
stack-array.cppExample 3
stack-linked-list.cpp