Stack using C

What is a stack? (LIFO)

A stack is one of the simplest and most useful data structures. It follows one rule: LIFO — Last In, First Out. The thing you added last is the first thing you take out.

Picture a pile of plates. You add plates on top, and you take from the top too. You cannot pull a plate from the middle without lifting the ones above. That is exactly how a stack behaves in C.

The core operations

All the action happens at the top. A single index variable called top keeps track of where that is.

Overflow and underflow

Two situations must always be checked:

• Overflow — pushing when the stack is already full (top is at the last index).
• Underflow — popping when the stack is empty (top is -1).

Array implementation

Here is a complete stack using an array, with all the safety checks.

#include <stdio.h>
#define SIZE 5
int stack[SIZE];
int top = -1;                 // empty stack

void push(int x) {
    if (top == SIZE - 1) { printf("Overflow\n"); return; }
    stack[++top] = x;          // move up, then store
}
int pop() {
    if (top == -1) { printf("Underflow\n"); return -1; }
    return stack[top--];       // return, then move down
}
int main() {
    push(10); push(20); push(30);
    printf("Popped: %d\n", pop());   // 30 (last in)
    printf("Popped: %d\n", pop());   // 20
    printf("Top now: %d\n", stack[top]); // 10
    return 0;
}

Notice 30 came out first even though 10 was pushed first — that is LIFO in action.

Where stacks are used

• Function calls — the computer uses a call stack to remember where to return.
• Undo/redo — the last action is undone first.
• Balanced brackets — checking that every ( has a matching ).
• Expression evaluation and backtracking algorithms.

Common mistakes

• Forgetting to check overflow before push or underflow before pop.
• Starting top at 0 instead of -1 for an empty stack.
• Mixing up the order in stack[++top] vs stack[top++].
• Trying to access elements in the middle — a stack only exposes the top.

Summary

• A stack follows LIFO — the last item pushed is the first popped.
• Core operations: push, pop, peek, isEmpty.
• Track the top with an index that starts at -1.
• Always check overflow before push and underflow before pop.
• Stacks power call stacks, undo, bracket matching and more.