Stack Operations

You already know a stack works like a pile of plates. You add a plate on top. You take a plate from the top. But how do you actually do that in code? You need a small set of operations. Every stack gives you these. Learn them once and you can use a stack in any language. So let us go through them one by one.

🎯 The Operations You Need

A stack only lets you touch the top. That sounds limiting at first. But that one rule is also what makes a stack fast and simple. Here are the operations that make a stack work.

• push — put a new item on top of the stack.
• pop — remove the top item and give it back to you.
• peek (also called top) — look at the top item without removing it.
• isEmpty — tell you if the stack has nothing in it.
• size — tell you how many items are inside.

That is the whole set. Every stack, in every language, is built from these. The big idea is LIFO, which means Last In First Out. The last item you pushed is the first item you pop.

📥 push — Add to the Top

The push operation takes one item and places it on top of the stack. Nothing below it moves. The new item simply becomes the new top.

Steps to push an item:

1. Take the item you want to add.
2. Place it on top of the stack.
3. The top now points to this new item.
4. The size goes up by one.

So if your stack has 10, 20 and you push 30, the stack becomes 10, 20, 30 with 30 on top.

📤 pop — Remove from the Top

The pop operation removes the top item and returns it. The item just below becomes the new top. The one case to be careful about is an empty stack. If there is nothing to remove, popping is an error. So you always check first.

Steps to pop an item:

1. Check if the stack is empty. If yes, stop. There is nothing to remove.
2. Read the top item.
3. Remove it from the stack.
4. The size goes down by one.
5. Return the removed item.

👀 peek — Look Without Removing

Sometimes you only want to see the top item. You do not want to remove it. That is what peek is for. It returns the top item but leaves the stack exactly as it was.

Steps to peek:

1. Check if the stack is empty. If yes, there is nothing to look at.
2. Read the top item.
3. Return it. Do not remove anything.

Think of peek as glancing at the top plate without lifting it off the pile.

❓ isEmpty and 📏 size

These two are small but you use them all the time.

• isEmpty returns true when the stack has no items, and false when it has at least one. You call it before pop and peek to stay safe.
• size returns the count of items currently in the stack. Handy when you need to know how much you are holding.

💻 All Operations in Code

Now let us see every operation working together. The code below pushes a few numbers, peeks at the top, checks the size, then pops items one by one and prints the stack each time. Each language uses its own built-in stack so you see the real, everyday way to do it.

#include <stdio.h>

#define MAX 100

int stack[MAX];
int top = -1;  // -1 means the stack is empty

// push: add an item on top
void push(int value) {
    stack[++top] = value;
}

// pop: remove and return the top item
int pop() {
    return stack[top--];
}

// peek: read the top without removing
int peek() {
    return stack[top];
}

// isEmpty: true when there is nothing inside
int isEmpty() {
    return top == -1;
}

// size: how many items are in the stack
int size() {
    return top + 1;
}

int main() {
    push(10);
    push(20);
    push(30);

    printf("Top item: %d\n", peek());
    printf("Size: %d\n", size());

    printf("Popped: %d\n", pop());
    printf("Popped: %d\n", pop());

    printf("Top item now: %d\n", peek());
    printf("Is empty? %s\n", isEmpty() ? "yes" : "no");
    printf("Size: %d\n", size());

    return 0;
}

Top item: 30
Size: 3
Popped: 30
Popped: 20
Top item now: 10
Is empty? no
Size: 1

#include <iostream>
#include <stack>
using namespace std;

int main() {
    stack<int> s;

    s.push(10);
    s.push(20);
    s.push(30);

    cout << "Top item: " << s.top() << endl;
    cout << "Size: " << s.size() << endl;

    cout << "Popped: " << s.top() << endl;
    s.pop();
    cout << "Popped: " << s.top() << endl;
    s.pop();

    cout << "Top item now: " << s.top() << endl;
    cout << "Is empty? " << (s.empty() ? "yes" : "no") << endl;
    cout << "Size: " << s.size() << endl;

    return 0;
}

Top item: 30
Size: 3
Popped: 30
Popped: 20
Top item now: 10
Is empty? no
Size: 1

import java.util.Stack;

public class StackOperations {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        stack.push(10);
        stack.push(20);
        stack.push(30);

        System.out.println("Top item: " + stack.peek());
        System.out.println("Size: " + stack.size());

        System.out.println("Popped: " + stack.pop());
        System.out.println("Popped: " + stack.pop());

        System.out.println("Top item now: " + stack.peek());
        System.out.println("Is empty? " + (stack.isEmpty() ? "yes" : "no"));
        System.out.println("Size: " + stack.size());
    }
}

Top item: 30
Size: 3
Popped: 30
Popped: 20
Top item now: 10
Is empty? no
Size: 1

# A Python list works as a stack
stack = []

# push: append adds to the end (the top)
stack.append(10)
stack.append(20)
stack.append(30)

# peek: the last element is the top
print("Top item:", stack[-1])
print("Size:", len(stack))

# pop: removes and returns the top
print("Popped:", stack.pop())
print("Popped:", stack.pop())

print("Top item now:", stack[-1])
print("Is empty?", "yes" if len(stack) == 0 else "no")
print("Size:", len(stack))

Top item: 30
Size: 3
Popped: 30
Popped: 20
Top item now: 10
Is empty? no
Size: 1

// A JavaScript array works as a stack
const stack = [];

// push: add to the end (the top)
stack.push(10);
stack.push(20);
stack.push(30);

// peek: the last element is the top
console.log("Top item:", stack[stack.length - 1]);
console.log("Size:", stack.length);

// pop: removes and returns the top
console.log("Popped:", stack.pop());
console.log("Popped:", stack.pop());

console.log("Top item now:", stack[stack.length - 1]);
console.log("Is empty?", stack.length === 0 ? "yes" : "no");
console.log("Size:", stack.length);

Top item: 30
Size: 3
Popped: 30
Popped: 20
Top item now: 10
Is empty? no
Size: 1

⏱️ How Fast Are These Operations?

This is the best part about a stack. Every core operation is O(1), which means constant time. It does not matter if your stack has ten items or ten million items. push, pop, and peek each touch only the top, so they take the same tiny amount of time.

🧩 What You’ve Learned

• ✅ A stack works with a small set of operations: push, pop, peek, isEmpty, and size.
• ✅ push adds to the top, pop removes from the top, and peek lets you look without removing.
• ✅ A stack follows LIFO, so the last item you push is the first one you pop.
• ✅ Always check isEmpty before you pop or peek, so you do not crash on an empty stack.
• ✅ Every core operation is O(1), meaning it stays fast no matter how big the stack grows.
• ✅ Each language has its own built-in stack: a list in Python, an array in JavaScript, std::stack in C++, the Stack class in Java, and a simple array with a top index in C.

🚀 What’s Next?

• Introduction to Stack
• Stack Using Array