Pop Operation on Stack in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after popping from the stack?

Consider a stack implemented as an array with the following operations. What is the printed stack after one pop operation?

DSA C

int stack[5] = {10, 20, 30, 40, 50};
int top = 4; // points to the last element
// Pop operation
if(top >= 0) {
    top--;
}
// Print stack from bottom to top
for(int i = 0; i <= top; i++) {
    printf("%d ", stack[i]);
}

A 10 20 30 40

B 10 20 30 40 50

C 20 30 40 50

D 10 20 30

💡 Hint

Remember, pop removes the top element from the stack.

The top index starts at 4, pointing to 50. After pop, top decreases to 3, so the stack elements from index 0 to 3 are printed: 10 20 30 40.

❓ Predict Output

intermediate

What happens if we pop from an empty stack?

Given the following code, what is the output?

DSA C

int stack[3] = {0};
int top = -1; // empty stack
// Pop operation
if(top >= 0) {
    top--;
} else {
    printf("Stack Underflow\n");
}

A No output

B 0

C Segmentation fault

D Stack Underflow

💡 Hint

Check the condition before popping.

Since top is -1, the stack is empty. The else block prints 'Stack Underflow'.

🔧 Debug

advanced

Identify the error in this pop operation code

What error will this code produce when popping from the stack?

DSA C

int stack[3] = {1, 2, 3};
int top = 0;
// Pop operation
if(top >= 0) {
    top--;
}
printf("Top element: %d\n", stack[top]);

A Undefined behavior due to incorrect pop condition

B Prints 2

C Prints 1 but pop is not done correctly

D Prints 1

💡 Hint

Check the condition for popping carefully.

The condition 'top > 0' prevents popping when top is 0, so pop never happens. The code prints stack[0] which is 1, but the pop operation is incorrect because it should allow popping when top is 0.

❓ Predict Output

advanced

What is the stack content after multiple pops?

Given the stack and operations below, what is the printed stack?

DSA C

int stack[6] = {5, 10, 15, 20, 25, 30};
int top = 5;
// Pop twice
for(int i = 0; i < 2; i++) {
    if(top >= 0) {
        top--;
    }
}
// Print stack
for(int i = 0; i <= top; i++) {
    printf("%d ", stack[i]);
}

A 15 20 25 30

B 5 10 15 20

C 5 10 15 20 25 30

D 5 10 15

💡 Hint

Each pop reduces the top index by one.

Starting top=5, after two pops top=3. Stack elements from 0 to 3 are printed: 5 10 15 20.

🧠 Conceptual

expert

What is the time complexity of the pop operation on a stack?

Choose the correct time complexity for the pop operation on a stack implemented using an array.

A O(1) - Constant time

B O(n) - Linear time

C O(log n) - Logarithmic time

D O(n^2) - Quadratic time

💡 Hint

Pop just moves the top pointer.

Pop operation only decrements the top index, which is a constant time operation.

Practice

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

easy

A. Returns the bottom element without removing it

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

C. Removes and returns the top element 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 at the top.

2. Step 2: Define pop operation

   The pop operation removes and returns this top element, reducing the stack size by one.

3. Final Answer:

   Removes and returns the top element of the stack -> Option C

4. Quick Check:

   Pop = remove top element [OK]

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

Common Mistakes:

• Thinking pop adds elements
• Confusing pop with peek
• Assuming pop removes bottom element

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

easy

A. pop(&stack);

B. stack.pop();

C. pop(stack);

D. stack.pop;

Solution

1. Step 1: Understand C function call for pop

   In C, stack is usually a struct or array, so pop function requires address to modify it.

2. Step 2: Identify correct syntax

   Passing &stack (address) to pop function is correct to modify stack state.

3. Final Answer:

   pop(&stack); -> Option A

4. Quick Check:

   Use & to pass stack address in C [OK]

Hint: Use & to pass stack pointer in C functions [OK]

Common Mistakes:

• Using dot notation like in C++ or Java
• Calling pop without & causing no stack change
• Missing parentheses in function call

3. What will be the output after executing the following code?

typedef struct {
  int arr[3];
  int top;
} Stack;

void pop(Stack *s) {
  if (s->top == -1) return;
  s->top--;
}

int main() {
  Stack s = {{10, 20, 30}, 2};
  pop(&s);
  printf("%d", s.arr[s.top]);
  return 0;
}

medium

A. 20

B. 30

C. 10

D. Runtime error

Solution

1. Step 1: Initial stack state

   Stack has elements [10, 20, 30] with top = 2 (pointing to 30).

2. Step 2: Perform pop operation

   Pop decreases top from 2 to 1, so top now points to 20.

3. Step 3: Print element at new top

   Printing s.arr[s.top] prints s.arr[1] which is 20.

4. Final Answer:

   20 -> Option A

5. Quick Check:

   Pop reduces top, new top element = 20 [OK]

Hint: Pop moves top down by one, print new top [OK]

Common Mistakes:

• Printing old top element after pop
• Confusing array index with top value
• Ignoring top decrement in pop

4. Identify the error in the following pop function for a stack and select the correct fix:

void pop(Stack *s) {
  if (s->top == 0) {
    printf("Stack Underflow\n");
    return;
  }
  s->top--;
}

medium

A. Add return value to pop function

B. Change condition to s->top == -1 to check empty stack

C. Change s->top-- to s->top++

D. Remove the if condition entirely

Solution

1. Step 1: Understand empty stack condition

   Stack is empty when top is -1, not 0, because top starts at -1.

2. Step 2: Fix condition to detect underflow

   Change condition to s->top == -1 to correctly detect empty stack before popping.

3. Final Answer:

   Change condition to s->top == -1 to check empty stack -> Option B

4. Quick Check:

   Empty stack top = -1, check before pop [OK]

Hint: Empty stack top is -1, not 0 [OK]

Common Mistakes:

• Checking top == 0 instead of -1
• Incrementing top on pop
• Ignoring underflow check

5. Given a stack implemented with an array of size 5 and top initially -1, after pushing 3 elements and then popping 4 times, what will be the value of top?

hard

A. 0

B. 1

C. -2

D. -1

Solution

1. Step 1: Calculate top after pushing 3 elements

   Starting top = -1, pushing 3 times increments top to 2 (0,1,2).

2. Step 2: Calculate top after popping 4 times

   Each pop decrements top by 1: 2 -> 1 -> 0 -> -1. The 4th pop tries to pop empty stack, top stays at -1.

3. Final Answer:

   -1 -> Option D

4. Quick Check:

   Pop beyond empty stack keeps top at -1 [OK]

Hint: Top never goes below -1 after pops [OK]

Common Mistakes:

• Assuming top can go below -1
• Counting pushes and pops incorrectly
• Ignoring underflow protection