Stack Implementation Using Array 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 implemented using an array with a maximum size of 5. The following operations are performed in order:

push(10), push(20), pop(), push(30), push(40), pop(), push(50), push(60), pop()

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

DSA C++

class Stack {
    int arr[5];
    int top = -1;
public:
    void push(int x) {
        if (top == 4) return; // stack full
        arr[++top] = x;
    }
    int pop() {
        if (top == -1) return -1; // stack empty
        return arr[top--];
    }
    void print() {
        for (int i = 0; i <= top; i++) {
            std::cout << arr[i] << " ";
        }
    }
};

int main() {
    Stack s;
    s.push(10);
    s.push(20);
    s.pop();
    s.push(30);
    s.push(40);
    s.pop();
    s.push(50);
    s.push(60);
    s.pop();
    s.print();
    return 0;
}

A 10 30 50

B 10 30 40 50

C 10 20 30 50

D 10 30 50 60

💡 Hint

Track the stack after each push and pop operation carefully.

After the sequence, the stack contains 10 at bottom, then 30, then 50 at top. Pops remove the last pushed element.

🧠 Conceptual

intermediate

What happens when you try to push an element into a full stack implemented using an array?

A stack is implemented using an array of fixed size 3. The stack currently has 3 elements. What will happen if you try to push another element?

A The stack throws an error and clears all elements.

B The new element is added, overwriting the bottom element.

C The push operation is ignored or rejected because the stack is full.

D The stack size automatically increases to accommodate the new element.

💡 Hint

Think about fixed size arrays and their capacity limits.

A fixed size array cannot grow. When full, push operations are rejected or ignored to prevent overflow.

🔧 Debug

advanced

What error does this stack pop function cause when the stack is empty?

Consider this pop function for a stack implemented using an array:

int pop() { return arr[top--]; }

What happens if pop() is called when the stack is empty (top == -1)?

DSA C++

int pop() {
    return arr[top--];
}

A Returns garbage value without error.

B Throws a compile-time error.

C Returns -1 safely.

D Causes an array index out of bounds error or undefined behavior.

💡 Hint

Check what happens when top is -1 and used as an index.

Accessing arr[-1] is invalid and causes undefined behavior or runtime error.

📝 Syntax

advanced

Which option correctly initializes an empty stack using an array in C++?

Choose the correct code snippet that initializes an empty stack with a fixed size array and top pointer.

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

B int arr[10]; int top = 0;

C int arr[10]; int top = 10;

D int arr[10]; int top = NULL;

💡 Hint

Remember top points to the last filled index or -1 if empty.

Top is -1 when stack is empty because no elements are pushed yet.

🚀 Application

expert

After performing these operations on a stack implemented with an array, what is the output of the print function?

Given a stack with max size 4, initially empty, perform:

push(5), push(10), push(15), pop(), push(20), push(25), pop(), pop(), push(30)

Then print the stack from bottom to top.

DSA C++

class Stack {
    int arr[4];
    int top = -1;
public:
    void push(int x) {
        if (top == 3) return;
        arr[++top] = x;
    }
    int pop() {
        if (top == -1) return -1;
        return arr[top--];
    }
    void print() {
        for (int i = 0; i <= top; i++) {
            std::cout << arr[i] << " ";
        }
    }
};

int main() {
    Stack s;
    s.push(5);
    s.push(10);
    s.push(15);
    s.pop();
    s.push(20);
    s.push(25);
    s.pop();
    s.pop();
    s.push(30);
    s.print();
    return 0;
}

A 5 20 30

B 5 10 30

C 5 10 20 30

D 5 30

💡 Hint

Track each push and pop carefully, updating the stack state.

After all operations, the stack contains 5, 10, 30 from bottom to top.

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