Pop Operation on Stack in DSA C++

Mental Model

A stack removes the top item first, like taking the last plate from a stack of plates.

Analogy: Imagine a stack of plates; you always take the top plate off first when you need one.

Top -> [3] -> [2] -> [1] -> null

Dry Run Walkthrough

Input: stack: 1 -> 2 -> 3, pop operation

Goal: Remove the top element (3) from the stack and show the new stack

Step 1: Check if stack is empty

Top -> [3] -> [2] -> [1] -> null

Why: We must ensure there is something to pop

Step 2: Remove the top element (3)

Top -> [2] -> [1] -> null

Why: Pop removes the last added item, which is at the top

Step 3: Return the popped value (3)

Top -> [2] -> [1] -> null

Why: We want to know which element was removed

Result:

Top -> [2] -> [1] -> null
Popped value: 3

Annotated Code

DSA C++

#include <iostream>
using namespace std;

class Stack {
private:
    struct Node {
        int data;
        Node* next;
        Node(int val) : data(val), next(nullptr) {}
    };
    Node* top;

public:
    Stack() : top(nullptr) {}

    void push(int val) {
        Node* newNode = new Node(val);
        newNode->next = top; // link new node to current top
        top = newNode;       // update top to new node
    }

    int pop() {
        if (top == nullptr) {
            cout << "Stack is empty, cannot pop.\n";
            return -1; // indicate empty stack
        }
        int val = top->data;       // save top value
        Node* temp = top;          // save top node
        top = top->next;           // move top down
        delete temp;               // free old top
        return val;                // return popped value
    }

    void print() {
        Node* curr = top;
        cout << "Top -> ";
        while (curr != nullptr) {
            cout << "[" << curr->data << "] -> ";
            curr = curr->next;
        }
        cout << "null\n";
    }
};

int main() {
    Stack s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.print();
    int popped = s.pop();
    s.print();
    cout << "Popped value: " << popped << "\n";
    return 0;
}

newNode->next = top; // link new node to current top

link new node to current top to keep stack order

top = newNode; // update top to new node

update top pointer to new node

if (top == nullptr) {

check if stack is empty before popping

int val = top->data; // save top value

store value to return after pop

top = top->next; // move top down

update top to next node, removing current top

delete temp; // free old top

free memory of popped node

Output

Top -> [3] -> [2] -> [1] -> null

Top -> [2] -> [1] -> null

Popped value: 3

Complexity Analysis

Time: O(1) because pop removes the top element directly without traversal

Space: O(1) because no extra space is needed for pop operation

vs Alternative: Compared to arrays where pop might require resizing or shifting, linked list pop is faster and simpler

Edge Cases

empty stack

pop returns -1 and prints a message that stack is empty

DSA C++

if (top == nullptr) {

stack with one element

pop removes the only element and top becomes nullptr

DSA C++

top = top->next;           // move top down

When to Use This Pattern

When you see a problem requiring last-in-first-out removal, reach for the stack pop operation because it removes the top element efficiently.

Common Mistakes

Mistake: Not checking if the stack is empty before popping
Fix: Add a condition to check if top is nullptr before removing

Mistake: Not updating the top pointer after pop
Fix: Set top to top->next to remove the current top node

Summary

Removes the top element from the stack and returns it.

Use when you need to retrieve and remove the last added item quickly.

The key is to update the top pointer to the next node to remove the current top.

Practice

1. What does the pop() operation do in a stack?

easy

A. Adds a new element to the bottom of the stack

B. Removes the top element from the stack

C. Returns the size of the stack

D. Clears all elements from the stack

Solution

1. Step 1: Understand stack behavior

   A stack follows Last In First Out (LIFO) principle, so the last added element is removed first.

2. Step 2: Define pop operation

   The pop operation removes the top element from the stack, which is the last inserted item.

3. Final Answer:

   Removes the top element from the stack -> Option B

4. Quick Check:

   pop() removes top element [OK]

Hint: Pop always removes the last added item [OK]

Common Mistakes:

• Thinking pop adds elements
• Confusing pop with peek or size
• Assuming pop clears the stack

2. Which of the following is the correct syntax to pop an element from a stack named stk in C++ STL?

easy

A. stk.pop();

B. pop(stk);

C. stk.pop_element();

D. stk.remove();

Solution

1. Step 1: Recall C++ STL stack syntax

   The standard stack class in C++ uses member functions like push() and pop() called on the stack object.

2. Step 2: Identify correct pop syntax

   The correct way to remove the top element is calling pop() as stk.pop();.

3. Final Answer:

   stk.pop(); -> Option A

4. Quick Check:

   Use object.pop() to remove top [OK]

Hint: Use object.pop() to remove top element [OK]

Common Mistakes:

• Using pop() as a free function
• Using incorrect method names like pop_element()
• Trying to remove with remove() which doesn't exist

3. What will be the output of the following C++ code?

std::stack<int> stk;
stk.push(10);
stk.push(20);
stk.pop();
std::cout << stk.top();

medium

A. 0

B. 20

C. 10

D. Compilation error

Solution

1. Step 1: Trace push operations

   First, 10 is pushed, then 20 is pushed on top. Stack top is now 20.

2. Step 2: Apply pop and check top

   pop() removes the top element (20), so top becomes 10. Printing top outputs 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   After pop, top is 10 [OK]

Hint: Pop removes last pushed, top shows new top [OK]

Common Mistakes:

• Assuming top remains 20 after pop
• Confusing pop with peek
• Expecting 0 or error output

4. Identify the error in the following code snippet that uses a stack:

std::stack<int> stk;
stk.pop();
stk.push(5);

medium

A. No error, code runs fine

B. Push should be called before pop

C. Stack declaration is incorrect

D. Pop called on empty stack causes runtime error

Solution

1. Step 1: Analyze stack state before pop

   The stack is empty initially. Calling pop() on empty stack is invalid and causes runtime error.

2. Step 2: Check order of operations

   Pop is called before any push, so no element exists to remove, causing error.

3. Final Answer:

   Pop called on empty stack causes runtime error -> Option D

4. Quick Check:

   Pop on empty stack causes error [OK]

Hint: Never pop from empty stack [OK]

Common Mistakes:

• Ignoring empty stack before pop
• Thinking push order fixes error
• Assuming pop on empty is safe

5. Given a stack with elements 1, 2, 3, 4 pushed in that order (1 at bottom, 4 at top), what will be the stack content after performing two pop() operations?

hard

A. 1 -> 2 -> null

B. 3 -> 4 -> null

C. 1 -> 2 -> 3 -> null

D. 4 -> 3 -> 2 -> 1 -> null

Solution

1. Step 1: Understand initial stack order

   Elements pushed in order: 1 (bottom), 2, 3, 4 (top). Stack looks like 1 -> 2 -> 3 -> 4 -> null.

2. Step 2: Apply two pop operations

   First pop removes 4 (top), second pop removes 3 (new top). Remaining stack is 1 -> 2 -> null.

3. Final Answer:

   1 -> 2 -> null -> Option A

4. Quick Check:

   Two pops remove top two elements [OK]

Hint: Pop removes top elements one by one [OK]

Common Mistakes:

• Confusing order of elements after pop
• Listing popped elements instead of remaining
• Reversing stack order incorrectly