Stack Implementation Using Array in DSA C - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA C

int stack[[1]];

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

A10

B1

C0

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 or 1 as the size which creates an invalid or too small array.

Using 10 which is larger than the required size.

The stack array should have a size of 5 to hold up to 5 elements.

2fill in blank

medium

Complete the code to initialize the top of the stack to -1, indicating an empty stack.

DSA C

int top = [1];

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

A-1

B0

C1

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Setting top to 0 which implies the stack has one element.

Using 5 which is out of array bounds.

Setting top to -1 means 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;
    } else {
        printf("Stack Overflow\n");
    }
}

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

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' which decreases the top index incorrectly.

Using '*' or '/' which are not suitable for incrementing.

We increase the top index by 1 before adding the new value.

4fill in blank

hard

Fill in the blank to correctly implement the pop function that removes and returns the top element.

DSA C

int pop(int stack[], int *top) {
    if (*top >= 0) {
        int value = stack[*top];
        *top = *top [1] 1;
        return value;
    } else {
        printf("Stack Underflow\n");
        return -1;
    }
}

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

A*

B-

C/

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' which incorrectly increases the top index.

Using '*' or '/' which are invalid here.

We decrease the top index by 1 after popping the element.

5fill in blank

hard

Fill all three blanks to complete the isEmpty function that checks if the stack is empty.

DSA C

int isEmpty(int [1][], int [2]) {
    if ([3] == -1) {
        return 1;
    } else {
        return 0;
    }
}

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

Astack

Btop

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong variable names or missing parameters.

Checking the wrong condition for emptiness.

The function takes the stack array and the top index as parameters. It checks if top equals -1 to determine emptiness.

Practice

1. What is the main purpose of using an array in stack implementation?

easy

A. To store elements in a fixed-size linear structure

B. To allow random access to elements anywhere in the stack

C. To automatically resize the stack when full

D. To sort elements in ascending order

Solution

1. Step 1: Understand stack storage

   A stack stores elements in a linear order where the last added element is accessed first.

2. Step 2: Role of array in stack

   An array provides a fixed-size linear structure to hold stack elements in order.

3. Final Answer:

   To store elements in a fixed-size linear structure -> Option A

4. Quick Check:

   Array = fixed-size linear storage [OK]

Hint: Stack uses array for fixed-size linear storage [OK]

Common Mistakes:

• Thinking array allows automatic resizing
• Confusing stack with random access structures
• Assuming array sorts elements automatically

2. Which of the following is the correct way to declare a stack array of size 5 in C?

easy

A. int[5] stack;

B. int stack[5];

C. stack int[5];

D. array stack = int[5];

Solution

1. Step 1: Recall C array declaration syntax

   In C, arrays are declared as: type name[size];

2. Step 2: Match syntax with options

   int stack[5]; matches correct syntax: int stack[5];

3. Final Answer:

   int stack[5]; -> Option B

4. Quick Check:

   C array declaration = int stack[5]; [OK]

Hint: C arrays declared as type name[size]; [OK]

Common Mistakes:

• Placing type after variable name
• Using incorrect keywords like 'array'
• Misplacing brackets in declaration

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

int stack[3];
int top = -1;
// Push 10
stack[++top] = 10;
// Push 20
stack[++top] = 20;
// Pop
int x = stack[top--];
printf("%d", stack[top]);

medium

A. Runtime error

B. 20

C. 10

D. Garbage value

Solution

1. Step 1: Trace push operations

   Initially top = -1.
   Push 10: top becomes 0, stack[0] = 10.
   Push 20: top becomes 1, stack[1] = 20.

2. Step 2: Trace pop and print

   Pop: x = stack[1] = 20, then top becomes 0.
   Print stack[top] = stack[0] = 10.

3. Final Answer:

   10 -> Option C

4. Quick Check:

   After pop, top points to 10 [OK]

Hint: Pop decreases top, print uses updated top [OK]

Common Mistakes:

• Printing popped element instead of current top
• Confusing pre-increment and post-decrement
• Assuming top points beyond last element

4. Identify the error in this stack push function and select the fix:

void push(int stack[], int *top, int size, int value) {
    if (*top == size) {
        printf("Stack Overflow\n");
        return;
    }
    stack[++(*top)] = value;
}

medium

A. No error, code is correct

B. Change condition to *top == size + 1

C. Change stack[++(*top)] to stack[(*top)++]

D. Change condition to *top == size - 1

Solution

1. Step 1: Understand top indexing in stack

   Top starts at -1, max index is size - 1.
   When top == size - 1, stack is full.

2. Step 2: Analyze overflow condition

   Condition *top == size is wrong; it should be *top == size - 1 to detect full stack.

3. Final Answer:

   Change condition to *top == size - 1 -> Option D

4. Quick Check:

   Overflow when top reaches size-1 [OK]

Hint: Top max index is size-1, not size [OK]

Common Mistakes:

• Checking top == size instead of size-1
• Misusing increment operators in array indexing
• Ignoring zero-based indexing

5. Given a stack implemented using an array of size 4, initially empty, what will be the stack content after these operations?

push(5);
push(10);
pop();
push(15);
push(20);
pop();
push(25);

Assume top starts at -1 and push/pop update top accordingly. Choose the correct final stack content from bottom to top.

hard

A. 5 -> 15 -> 25 -> null

B. 5 -> 10 -> 15 -> 25 -> null

C. 10 -> 15 -> 25 -> null

D. 5 -> 15 -> 20 -> 25 -> null

Solution

1. Step 1: Trace each operation step-by-step

   Start: top = -1, stack empty.
   push(5): top=0, stack[0]=5
   push(10): top=1, stack[1]=10
   pop(): removes 10, top=0
   push(15): top=1, stack[1]=15
   push(20): top=2, stack[2]=20
   pop(): removes 20, top=1
   push(25): top=2, stack[2]=25

2. Step 2: Final stack content

   Stack from bottom (index 0) to top (index 2): 5, 15, 25

3. Final Answer:

   5 -> 15 -> 25 -> null -> Option A

4. Quick Check:

   Push/pop update top correctly [OK]

Hint: Track top index after each push/pop [OK]

Common Mistakes:

• Forgetting to update top after pop
• Assuming pop removes bottom element
• Mixing order of elements after operations