Pop Operation on Stack in DSA C++ - Build from Scratch

Pop Operation on Stack

📖 Scenario: Imagine you have a stack of books. You can only take the top book off the stack at a time. This is how a stack data structure works in programming.

🎯 Goal: You will create a stack using a list, then remove the top item using the pop operation, and finally print the stack after popping.

📋 What You'll Learn

Create a stack with exact elements: 10, 20, 30, 40, 50

Create an integer variable called top to track the index of the top element

Implement the pop operation by decreasing top and removing the top element

Print the stack elements from bottom to top after the pop operation

💡 Why This Matters

🌍 Real World

Stacks are used in many real-world applications like undo features in text editors, browser history, and expression evaluation.

💼 Career

Understanding stack operations is essential for software development roles, especially those involving algorithms, system design, and debugging.

1

Create the stack

Create a vector of integers called stack with these exact elements: 10, 20, 30, 40, 50.

DSA C++

#include 
#include 

int main() {
    // Create the stack vector with elements 10, 20, 30, 40, 50
    // Your code here
    return 0;
}

Hint

Use std::vector<int> and initialize it with the given numbers inside curly braces.

2

Set the top index

Create an integer variable called top and set it to the index of the last element in stack.

DSA C++

#include 
#include 

int main() {
    std::vector stack = {10, 20, 30, 40, 50};
    // Create an integer variable top and set it to the last index of stack
    // Your code here
    return 0;
}

Hint

Use stack.size() - 1 to get the last index of the vector.

3

Pop the top element

Remove the top element from stack using pop_back() and decrease top by 1.

DSA C++

#include 
#include 

int main() {
    std::vector stack = {10, 20, 30, 40, 50};
    int top = stack.size() - 1;
    // Remove the top element from stack and decrease top by 1
    // Your code here
    return 0;
}

Hint

Use stack.pop_back() to remove the last element and then decrease top by 1.

4

Print the stack after pop

Use a for loop with variable i from 0 to top inclusive to print each element of stack separated by spaces.

DSA C++

#include 
#include 

int main() {
    std::vector stack = {10, 20, 30, 40, 50};
    int top = stack.size() - 1;
    stack.pop_back();
    top--;
    // Print the stack elements from index 0 to top separated by spaces
    // Your code here
    return 0;
}

Hint

Use a for loop from 0 to top and print each element with a space after it.

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