Stack Concept and LIFO Principle in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this stack push and pop sequence?

Consider a stack initially empty. We perform these operations in order:
push(5), push(10), pop(), push(15), pop(), pop().
What is the output of each pop operation?

DSA C

Stack operations:
push(5)
push(10)
pop() -> ?
push(15)
pop() -> ?
pop() -> ?

A [10, 15, 5]

B [5, 10, 15]

C [15, 10, 5]

D [5, 15, 10]

💡 Hint

Remember stack follows Last In First Out (LIFO). The last pushed item is popped first.

The first pop removes 10 (last pushed), second pop removes 15, third pop removes 5.

🧠 Conceptual

intermediate

Which statement correctly describes the LIFO principle in stacks?

Choose the statement that best explains how the LIFO principle works in a stack.

A The first element added is the first one to be removed.

B Elements are removed in the reverse order they were added.

C The last element added is the last one to be removed.

D Elements are removed randomly regardless of insertion order.

💡 Hint

Think about which element is on top of the stack.

LIFO means last in, first out, so the last element added is removed first.

🔧 Debug

advanced

What error occurs in this stack pop implementation?

Given this C code snippet for popping from a stack, what error will occur if the stack is empty?

int pop() {
  if (top == -1) {
    return stack[top];
  }
  return stack[top--];
}

DSA C

int pop() {
  if (top == -1) {
    return stack[top];
  }
  return stack[top--];
}

A No error, works fine

B Stack underflow error handled correctly

C Syntax error due to missing braces

D Returns garbage value from invalid index

💡 Hint

Check what happens when top is -1 and you access stack[top].

When top is -1, accessing stack[-1] is invalid and returns garbage or causes runtime error.

📝 Syntax

advanced

Which option correctly declares a stack array and top variable in C?

Choose the correct C code snippet to declare a stack of size 10 and initialize top to -1.

A int stack[10]; int top = -1;

B int stack; int top = 0;

C int stack[10]; int top = 0;

D int stack[] = 10; int top = -1;

💡 Hint

Stack is an array, top starts at -1 to indicate empty stack.

Option A correctly declares an integer array and initializes top to -1.

🚀 Application

expert

After these stack operations, what is the stack content?

Start with an empty stack. Perform:
push(1), push(2), push(3), pop(), push(4), pop(), push(5).
What is the final stack content from bottom to top?

A 1 -> 3 -> 5 -> null

B 1 -> 4 -> 5 -> null

C 1 -> 2 -> 5 -> null

D 2 -> 4 -> 5 -> null

💡 Hint

Track each push and pop carefully, remembering LIFO order.

Pop removes 3, then pop removes 4, so stack ends with 1, 2, 5.

Practice

1. What does the LIFO principle mean in the context of a stack?

easy

A. First In, First Out - the first element added is removed first

B. Last In, First Out - the last element added is removed first

C. Last In, First Out - the first element added is removed first

D. First In, Last Out - the first element added is removed last

Solution

1. Step 1: Understand LIFO meaning

   LIFO means the last element added to the stack is the first one to be removed.

2. Step 2: Match with options

   Last In, First Out - the last element added is removed first correctly describes this behavior as "Last In, First Out".

3. Final Answer:

   Last In, First Out - the last element added is removed first -> Option B

4. Quick Check:

   LIFO = Last In, First Out [OK]

Hint: Remember stack removes newest item first [OK]

Common Mistakes:

• Confusing LIFO with FIFO
• Thinking first added is removed first
• Mixing up order of insertion and removal

2. Which of the following is the correct way to push an element 'x' onto a stack named 's' in C?

easy

A. s.push = x;

B. s.push(x);

C. push(x, s);

D. push(s, x);

Solution

1. Step 1: Identify correct function call syntax in C

   In C, stack operations are usually functions like push(stack, element).

2. Step 2: Check options

   push(s, x); uses push(s, x); which is the correct syntax for pushing x onto stack s.

3. Final Answer:

   push(s, x); -> Option D

4. Quick Check:

   Function call push(stack, element) = push(s, x) [OK]

Hint: In C, function calls have parameters in parentheses [OK]

Common Mistakes:

• Using object.method() syntax (not C style)
• Swapping parameter order
• Assigning instead of calling function

3. Consider the following C code using a stack with push and pop operations:

push(s, 10);
push(s, 20);
pop(s);
push(s, 30);
pop(s);

What is the value returned by the last pop operation?

medium

A. 30

B. 20

C. 10

D. Error - stack empty

Solution

1. Step 1: Trace stack after each operation

   After push 10: stack = [10]
   After push 20: stack = [10, 20]
   pop(): removes 20, stack = [10]
   push 30: stack = [10, 30]
   pop(): removes 30

2. Step 2: Identify last pop value

   The last pop removes 30, so it returns 30.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Last pop returns last pushed element 30 [OK]

Hint: Last pushed is first popped, track stack top [OK]

Common Mistakes:

• Assuming FIFO order
• Forgetting previous pop removed top
• Mixing values pushed and popped

4. The following C code snippet is intended to pop an element from a stack 's'. What is the error?

int pop(Stack *s) {
    if (s->top == -1) {
        return -1;
    }
    return s->items[s->top++];
}

medium

A. The function returns -1 on empty stack

B. The stack pointer is not checked for NULL

C. The top index is incremented instead of decremented

D. The return type should be void

Solution

1. Step 1: Analyze pop operation logic

   Pop should return the top element and then decrease the top index.

2. Step 2: Identify error in index update

   Code uses s->top++ which increases top, wrong for pop. It should be s->top-- to remove top element.

3. Final Answer:

   The top index is incremented instead of decremented -> Option C

4. Quick Check:

   Pop decreases top index, not increases [OK]

Hint: Pop must decrease top index after returning element [OK]

Common Mistakes:

• Using post-increment instead of decrement
• Ignoring empty stack check
• Wrong return type for pop

5. You have a stack initially empty. You perform these operations:

push(s, 5);
push(s, 10);
pop(s);
push(s, 15);
push(s, 20);
pop(s);
pop(s);

What is the final state of the stack (from top to bottom)?

hard

A. 5

B. 10 -> 5

C. 15 -> 5

D. Empty stack

Solution

1. Step 1: Trace stack after each operation

   push 5: stack = [5]
   push 10: stack = [5, 10]
   pop: removes 10, stack = [5]
   push 15: stack = [5, 15]
   push 20: stack = [5, 15, 20]
   pop: removes 20, stack = [5, 15]
   pop: removes 15, stack = [5]

2. Step 2: Determine final stack state

   After all operations, stack has only 5 left at bottom and top.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Only 5 remains after pops [OK]

Hint: Track pushes and pops carefully to find final stack [OK]

Common Mistakes:

• Forgetting to remove top on pop
• Mixing order of elements
• Assuming stack is empty after pops