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 hold the stack elements.

DSA C#

private int[] stackArray = new int[[1]];

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

AstackSize

B10

Csize

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using a fixed number instead of the variable for size.

Using a variable that counts elements instead of size.

The stack array size should be set using the variable stackSize which defines the maximum capacity of the stack.

2fill in blank

medium

Complete the code to check if the stack is empty.

DSA C#

public bool IsEmpty() {
    return top [1] -1;
}

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

A>

B==

C<

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using greater than or less than instead of equality.

Checking against 0 instead of -1.

The stack is empty when top equals -1, meaning no elements are in the stack.

3fill in blank

hard

Fix the error in the Push method to correctly add an element to the stack.

DSA C#

public void Push(int value) {
    if (top [1] stackSize - 1) {
        Console.WriteLine("Stack Overflow");
        return;
    }
    stackArray[++top] = value;
}

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

A==

B<=

C>=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using less than or equal instead of greater than or equal.

Using equality only which misses some overflow cases.

The stack is full when top is greater than or equal to stackSize - 1. This prevents adding beyond capacity.

4fill in blank

hard

Fill both blanks to correctly implement the Pop method that removes and returns the top element.

DSA C#

public int Pop() {
    if (top [1] -1) {
        Console.WriteLine("Stack Underflow");
        return -1;
    }
    return stackArray[top[2]];
}

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

A==

B>

C--

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using > or < instead of == for empty check.

Incrementing top instead of decrementing.

The stack is empty if top == -1. To pop, return the element at top then decrement top using --.

5fill in blank

hard

Complete the code to implement the Peek method that returns the top element without removing it.

DSA C#

public int Peek() {
    if (top [1] -1) {
        Console.WriteLine("Stack is empty");
        return -1;
    }
    return stackArray[top];
}

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

A==

B>

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Changing top when peeking.

Using > or < instead of == for empty check.

The Peek method checks if the stack is empty by top == -1. It returns the element at top without changing top, so no increment or decrement is needed (empty string for operator).

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