Stack Implementation Using Array in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the array that will store stack elements.

DSA C++

int stack[[1]];

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

A100

Bsize

Ctop

Dstack

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names like 'size' or 'top' instead of a number.

Leaving the array size empty.

The stack array size must be a fixed integer like 100 to store elements.

2fill in blank

medium

Complete the code to initialize the top of the stack.

DSA C++

int top = [1];

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

A-1

B0

C1

Dstack

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing top to 0 which means stack has one element.

Using variable names instead of a number.

Top is initialized to -1 to indicate the stack is empty.

3fill in blank

hard

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

DSA C++

void push(int value) {
    if(top == 99) {
        cout << "Stack Overflow" << endl;
    } else {
        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 '-' which decreases top.

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

We increase top by 1 before adding the new element.

4fill in blank

hard

Fill both blanks to complete the pop function that removes the top element.

DSA C++

int pop() {
    if(top == [1]) {
        cout << "Stack Underflow" << endl;
        return -1;
    } else {
        int value = stack[top];
        top [2];
        return value;
    }
}

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

A-1

B0

C--

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if top is 0 instead of -1.

Using '+' instead of '--' to update top.

Check if top is -1 for empty stack, then decrease top by 1 after popping.

5fill in blank

hard

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

DSA C++

bool isEmpty() {
    if(top [1] [2]) {
        return [3];
    } else {
        return false;
    }
}

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

A==

B-1

Ctrue

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using '=' instead of '==' for comparison.

Comparing top with 0 instead of -1.

Returning false when stack is empty.

Stack is empty if top == -1, then return true.

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

C. To sort elements automatically

D. To store elements in a tree-like structure

Solution

1. Step 1: Understand stack storage

   A stack stores elements in a linear order, last-in first-out (LIFO).

2. Step 2: Role of array in stack

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

3. Final Answer:

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

4. Quick Check:

   Stack uses array for fixed linear storage [OK]

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

Common Mistakes:

• Confusing stack with queue or tree
• Thinking array sorts elements automatically
• Assuming stack allows random access

2. Which of the following is the correct syntax to declare a stack array of size 10 in C++?

easy

A. stack int[10];

B. int stack[10];

C. int stack();

D. array stack[10];

Solution

1. Step 1: Recall C++ array declaration syntax

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

2. Step 2: Match with options

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

3. Final Answer:

   int stack[10]; -> Option B

4. Quick Check:

   C++ array declaration = int stack[10]; [OK]

Hint: Array declaration: type name[size]; [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Wrong order of type and name
• Using non-existent 'array' keyword

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

int stack[5];
int top = -1;
// Push 10
stack[++top] = 10;
// Push 20
stack[++top] = 20;
// Pop
int x = stack[top--];
// Push 30
stack[++top] = 30;
// Print top element
std::cout << stack[top];

medium

A. Runtime error

B. 20

C. 10

D. 30

Solution

1. Step 1: Trace stack operations step-by-step

   Initially top = -1.
   Push 10: top=0, stack[0]=10
   Push 20: top=1, stack[1]=20
   Pop: x=stack[1]=20, top=0
   Push 30: top=1, stack[1]=30

2. Step 2: Identify top element after operations

   Top is 1, stack[1] = 30, so output is 30.

3. Final Answer:

   30 -> Option D

4. Quick Check:

   Last pushed after pop is 30 [OK]

Hint: Track top index changes carefully [OK]

Common Mistakes:

• Confusing push and pop order
• Not updating top correctly
• Assuming pop removes element permanently

4. Identify the error in the following stack push function using array:

void push(int stack[], int &top, int size, int value) {
  if (top == size) {
    std::cout << "Stack Overflow";
    return;
  }
  stack[++top] = value;
}

medium

A. No error, function is correct

B. The increment of top should be after assignment

C. The condition should be 'top == size - 1' to check overflow

D. The function should return a value

Solution

1. Step 1: Understand overflow condition

   Array indices go from 0 to size-1, so top can be max size-1.

2. Step 2: Check condition in code

   Condition 'top == size' is wrong; it should be 'top == size - 1' to prevent overflow.

3. Final Answer:

   The condition should be 'top == size - 1' to check overflow -> Option C

4. Quick Check:

   Overflow check uses top == size - 1 [OK]

Hint: Array max index = size - 1 for overflow check [OK]

Common Mistakes:

• Checking top == size instead of size - 1
• Incrementing top incorrectly
• Ignoring overflow condition

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

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

Assume stack is initially empty and top = -1. Choose the correct stack content from bottom to top.

hard

A. 5 -> 15 -> 20 -> null

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

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

D. 10 -> 15 -> 20 -> null

Solution

1. Step 1: Execute operations 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
   push(25): top=3, stack[3]=25 (stack full)
   pop(): removes 25, top=2

2. Step 2: Final stack content

   Stack from bottom to top: 5 (index 0), 15 (index 1), 20 (index 2). So output is 5 -> 15 -> 20 -> null.

3. Final Answer:

   5 -> 15 -> 20 -> null -> Option A

4. Quick Check:

   Track push/pop changes carefully [OK]

Hint: Write each push/pop step to track stack state [OK]

Common Mistakes:

• Ignoring pop effects on top
• Assuming stack grows beyond size
• Confusing order of elements