Stack Concept and LIFO Principle in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a stack array of size 5.

DSA C

int stack[[1]];

Drag options to blanks, or click blank then click option'

A5

B7

C3

D10

Attempts:

3 left

💡 Hint

Common Mistakes

Using a size other than 5.

Forgetting to specify the size.

The stack array size is 5 to hold 5 elements.

2fill in blank

medium

Complete the code to initialize the top of the stack to -1.

DSA C

int top = [1];

Drag options to blanks, or click blank then click option'

A1

B0

C-1

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Setting top to 0 which means stack has one element.

Using positive numbers initially.

Top is set to -1 to indicate the stack is empty initially.

3fill in blank

hard

Fix the error in the push function to correctly add an element to the stack.

DSA C

void push(int stack[], int *top, int value) {
    if (*top < 4) {
        *top = *top [1] 1;
        stack[*top] = value;
    }
}

Drag options to blanks, or click blank then click option'

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction which moves top backward.

Using multiplication or division which is incorrect here.

We add 1 to top to move to the next empty position before inserting.

4fill in blank

hard

Fill both blanks to correctly pop an element from the stack.

DSA C

int pop(int stack[], int *top) {
    int value = stack[*top];
    *top = *top [1] 1;
    return value;
}

Drag options to blanks, or click blank then click option'

A/

B+

C*

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition which moves top forward incorrectly.

Using multiplication or division which is invalid here.

We subtract 1 from top to move down after popping the element.

5fill in blank

hard

Fill all three blanks to check if the stack is empty and print a message.

DSA C

if (top [1] [2]) {
    printf("Stack is [3]\n");
}

Drag options to blanks, or click blank then click option'

A==

B!=

C-1

Dempty

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '=='.

Comparing top with 0 instead of -1.

Printing wrong message.

We check if top equals -1 to know stack is empty and print 'empty'.

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