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. This project will help you understand how to remove (pop) the top item from a stack using C programming.

🎯 Goal: You will build a simple stack with 3 items and then remove the top item using the pop operation. Finally, you will print the stack after popping to see the result.

📋 What You'll Learn

Create an integer array called stack with exactly these values: 10, 20, 30

Create an integer variable called top and set it to 2 (index of the last item)

Write code to pop the top item from the stack by decreasing top by 1

Print the stack elements from index 0 to top inclusive

💡 Why This Matters

🌍 Real World

Stacks are used in many places like undo features in apps, browser history, and managing function calls.

💼 Career

Understanding stack operations is important for software developers, especially when working with algorithms, memory management, and system programming.

1

Create the stack array

Create an integer array called stack with exactly these values: 10, 20, 30

DSA C

# Create the stack array with values 10, 20, 30
// Your code here

Hint

Use curly braces to list the values inside the array.

2

Set the top index

Create an integer variable called top and set it to 2 (the index of the last item in the stack)

DSA C

int stack[3] = {10, 20, 30};
// Create the top variable and set it to 2
// Your code here

Hint

The top variable tells us where the last item is in the stack.

3

Pop the top item

Decrease the value of top by 1 to pop the top item from the stack

DSA C

int stack[3] = {10, 20, 30};
int top = 2;
// Pop the top item by decreasing top
// Your code here

Hint

Subtract 1 from top to remove the last item.

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

int stack[3] = {10, 20, 30};
int top = 2;
top = top - 1;
// Print stack elements from index 0 to top
// Your code here

Hint

Use printf inside the loop to print each element followed by a space.

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