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 3. The following operations are performed in order:

Push(10), Push(20), Pop(), Push(30), Push(40), Pop(), Pop()

What is the printed output of the popped elements?

DSA C#

class Stack {
    private int[] arr = new int[3];
    private int top = -1;

    public void Push(int x) {
        if (top == arr.Length - 1) return;
        arr[++top] = x;
    }

    public int Pop() {
        if (top == -1) return -1;
        return arr[top--];
    }
}

var stack = new Stack();
stack.Push(10);
stack.Push(20);
Console.WriteLine(stack.Pop());
stack.Push(30);
stack.Push(40);
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Pop());

A 10\n40\n30

B 20\n30\n40

C 20\n40\n30

D 20\n30\n10

💡 Hint

Remember that pop removes the top element and push adds on top if space is available.

The stack operations proceed as follows: Push 10 and 20, stack is [10,20]. Pop removes 20. Push 30 and 40, stack is [10,30,40]. Pop removes 40, next pop removes 30. So outputs are 20, 40, 30.

❓ Predict Output

intermediate

What is the stack size after these operations?

Given a stack implemented using an array with max size 5, the following operations are done:

Push(5), Push(10), Pop(), Push(15), Push(20), Pop(), Push(25)

What is the size of the stack after these operations?

DSA C#

class Stack {
    private int[] arr = new int[5];
    private int top = -1;

    public void Push(int x) {
        if (top == arr.Length - 1) return;
        arr[++top] = x;
    }

    public void Pop() {
        if (top == -1) return;
        top--;
    }

    public int Size() {
        return top + 1;
    }
}

var stack = new Stack();
stack.Push(5);
stack.Push(10);
stack.Pop();
stack.Push(15);
stack.Push(20);
stack.Pop();
stack.Push(25);
Console.WriteLine(stack.Size());

A 3

B 4

C 2

D 5

💡 Hint

Count pushes and pops carefully to find current stack size.

Operations: Push 5 (size 1), Push 10 (2), Pop (1), Push 15 (2), Push 20 (3), Pop (2), Push 25 (3). Final size is 3.

🔧 Debug

advanced

Identify the error in this stack pop method

This pop method is part of a stack implemented using an array. What error will occur when calling Pop on an empty stack?

DSA C#

public int Pop() {
    if (top == 0) {
        return -1;
    }
    return arr[top--];
}

A Throws IndexOutOfRangeException when stack is empty

B Returns -1 correctly when stack is empty

C Returns wrong element but no error

D Causes infinite loop

💡 Hint

Check the condition that detects empty stack carefully.

The condition 'if (top == 0)' wrongly treats top=0 as empty, but top starts at -1 when empty. So when top is -1, the code tries to access arr[-1], causing IndexOutOfRangeException.

🧠 Conceptual

advanced

What happens when pushing onto a full stack array?

If a stack is implemented using an array of fixed size 4, and the stack currently holds 4 elements, what happens when you try to push another element?

A The stack throws an exception and crashes

B The push operation is ignored or rejected

C The array automatically resizes to hold more elements

D The new element replaces the bottom element

💡 Hint

Fixed size arrays cannot grow automatically.

In a fixed size array stack, pushing when full does nothing or rejects the push. It does not replace elements or resize automatically. Exception throwing depends on implementation but usually push is ignored.

🚀 Application

expert

Trace the stack content after a complex sequence

Given a stack with max size 5, initially empty, perform these operations:

Push(1), Push(2), Push(3), Pop(), Push(4), Pop(), Pop(), Push(5), Push(6)

What is the final stack content from bottom to top?

DSA C#

class Stack {
    private int[] arr = new int[5];
    private int top = -1;

    public void Push(int x) {
        if (top == arr.Length - 1) return;
        arr[++top] = x;
    }

    public int Pop() {
        if (top == -1) return -1;
        return arr[top--];
    }

    public string PrintStack() {
        if (top == -1) return "Empty";
        var result = new System.Text.StringBuilder();
        for (int i = 0; i <= top; i++) {
            result.Append(arr[i]);
            if (i != top) result.Append(" -> ");
        }
        return result.ToString();
    }
}

var stack = new Stack();
stack.Push(1);
stack.Push(2);
stack.Push(3);
stack.Pop();
stack.Push(4);
stack.Pop();
stack.Pop();
stack.Push(5);
stack.Push(6);
Console.WriteLine(stack.PrintStack());

A 2 -> 5 -> 6

B 1 -> 2 -> 5 -> 6

C 5 -> 6

D 1 -> 5 -> 6

💡 Hint

Track each push and pop carefully, updating the stack content step by step.

Operations: Push 1,2,3 stack=[1,2,3]. Pop removes 3 stack=[1,2]. Push 4 stack=[1,2,4]. Pop removes 4 stack=[1,2]. Pop removes 2 stack=[1]. Push 5 stack=[1,5]. Push 6 stack=[1,5,6]. Final stack is 1 -> 5 -> 6.

Practice

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

easy

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

B. To store elements in a fixed-size, ordered collection

C. To automatically resize the stack when full

D. To sort elements as they are added

Solution

1. Step 1: Understand stack storage

   A stack stores elements in order, last-in first-out, so it needs a structure to hold elements sequentially.

2. Step 2: Role of array in stack

   An array provides a fixed-size, ordered collection to hold stack elements efficiently.

3. Final Answer:

   To store elements in a fixed-size, ordered collection -> Option B

4. Quick Check:

   Stack uses array for fixed order storage [OK]

Hint: Stack uses array for fixed order storage, not random access [OK]

Common Mistakes:

• Thinking array resizes automatically
• Confusing stack with queue behavior
• Assuming array sorts elements

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

easy

A. int[] stack = new int[5];

B. int stack = new int[5];

C. int[] stack = int[5];

D. stack int[] = new int(5);

Solution

1. Step 1: Recall C# array declaration syntax

   In C#, arrays are declared with type[], variable name, and new type[size].

2. Step 2: Match correct syntax

   int[] stack = new int[5]; matches this pattern: int[] stack = new int[5];

3. Final Answer:

   int[] stack = new int[5]; -> Option A

4. Quick Check:

   C# array declaration = int[] name = new int[size]; [OK]

Hint: Use type[] name = new type[size]; for arrays in C# [OK]

Common Mistakes:

• Missing [] after type
• Using parentheses instead of brackets
• Incorrect variable declaration order

3. What will be the output after the following operations on a stack implemented using an array of size 3?

Push(10); Push(20); Pop(); Push(30); Pop(); Pop();

Assume the stack is initially empty and prints the popped values.

medium

A. 20 30 10

B. 20 30 20

C. 20 30 30

D. 10 20 30

Solution

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

   Push(10) stack=[10]
   Push(20) stack=[10,20]
   Pop() removes 20, output=20, stack=[10]
   Push(30) stack=[10,30]
   Pop() removes 30, output=30, stack=[10]
   Pop() removes 10, output=10, stack=[]

2. Step 2: Collect popped outputs in order

   The popped values printed are 20, then 30, then 10.

3. Final Answer:

   20 30 10 -> Option A

4. Quick Check:

   Stack LIFO pop order = 20 30 10 [OK]

Hint: Pop prints last pushed element, follow LIFO order [OK]

Common Mistakes:

• Confusing push and pop order
• Assuming FIFO instead of LIFO
• Missing last pop output

4. Identify the error in this stack push method code snippet in C#:

public void Push(int item) {
  if (top == stack.Length) {
    Console.WriteLine("Stack Overflow");
  }
  stack[top] = item;
  top++;
}

medium

A. top should be compared with stack.Length - 1

B. top++ should be before assigning stack[top]

C. No return after overflow check causes overwrite

D. stack array should be resized when full

Solution

1. Step 1: Analyze overflow check logic

   The code checks if top == stack.Length and prints overflow, but continues to assign and increment top anyway.

2. Step 2: Identify missing control flow after overflow

   Without a return or exit after overflow message, the code overwrites stack[top] causing error.

3. Final Answer:

   No return after overflow check causes overwrite -> Option C

4. Quick Check:

   Overflow check must stop push to avoid overwrite [OK]

Hint: Stop push after overflow check to prevent overwrite [OK]

Common Mistakes:

• Assuming top comparison off by one
• Moving top++ before assignment causes wrong index
• Ignoring need to stop after overflow

5. You want to implement a stack using an array that doubles its size automatically when full. Which approach correctly achieves this in C#?

hard

A. Increase the size of the existing array using stack.Resize() method

B. Overwrite oldest elements when stack is full to make space

C. Use a List<int> instead of array to avoid resizing manually

D. Create a new array double the size, copy elements, then assign it to the stack variable

Solution

1. Step 1: Understand array resizing in C#

   Arrays have fixed size; to resize, create a new larger array and copy elements over.

2. Step 2: Evaluate options for resizing stack array

   Create a new array double the size, copy elements, then assign it to the stack variable correctly describes creating a new array double the size, copying elements, and reassigning stack variable.

3. Final Answer:

   Create a new array double the size, copy elements, then assign it to the stack variable -> Option D

4. Quick Check:

   Resize array by new array + copy + assign [OK]

Hint: Arrays fixed size; resize by new array and copy [OK]

Common Mistakes:

• Assuming arrays can resize in place
• Using non-existent Resize method on arrays
• Overwriting data instead of resizing