Check if Stack is Empty or Full in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this stack check code?

Consider a stack with a maximum size of 3. After pushing two elements, what will be the output of the empty and full checks?

DSA C#

using System;

class Stack {
    private int[] items;
    private int top;
    private int maxSize;

    public Stack(int size) {
        maxSize = size;
        items = new int[maxSize];
        top = -1;
    }

    public void Push(int item) {
        if (!IsFull()) {
            items[++top] = item;
        }
    }

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

    public bool IsFull() {
        return top == maxSize - 1;
    }
}

class Program {
    static void Main() {
        Stack stack = new Stack(3);
        stack.Push(10);
        stack.Push(20);
        Console.WriteLine(stack.IsEmpty());
        Console.WriteLine(stack.IsFull());
    }
}

A False\nTrue

B True\nFalse

C False\nFalse

D True\nTrue

💡 Hint

Think about how many elements are pushed and the stack's max size.

The stack has size 3 and two elements pushed. So it is not empty (IsEmpty() returns false) and not full (IsFull() returns false).

❓ Predict Output

intermediate

What happens when pushing to a full stack?

Given a stack of size 2, after pushing two elements, what will be the output of the full check and what happens if we push one more element?

DSA C#

using System;

class Stack {
    private int[] items;
    private int top;
    private int maxSize;

    public Stack(int size) {
        maxSize = size;
        items = new int[maxSize];
        top = -1;
    }

    public void Push(int item) {
        if (!IsFull()) {
            items[++top] = item;
        }
    }

    public bool IsFull() {
        return top == maxSize - 1;
    }

    public int Top() {
        if (top >= 0) return items[top];
        return -1;
    }
}

class Program {
    static void Main() {
        Stack stack = new Stack(2);
        stack.Push(5);
        stack.Push(15);
        Console.WriteLine(stack.IsFull());
        stack.Push(25);
        Console.WriteLine(stack.Top());
    }
}

A False\n25

B True\n15

C True\n25

D False\n15

💡 Hint

Check if the push method prevents adding when full.

The stack is full after pushing 5 and 15. The third push is ignored. So IsFull() returns true and Top() returns 15.

❓ Predict Output

advanced

What is the output after popping all elements and checking empty?

Given a stack of size 2, after pushing two elements and popping both, what will be the output of the empty check?

DSA C#

using System;

class Stack {
    private int[] items;
    private int top;
    private int maxSize;

    public Stack(int size) {
        maxSize = size;
        items = new int[maxSize];
        top = -1;
    }

    public void Push(int item) {
        if (!IsFull()) {
            items[++top] = item;
        }
    }

    public int Pop() {
        if (!IsEmpty()) {
            return items[top--];
        }
        return -1;
    }

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

class Program {
    static void Main() {
        Stack stack = new Stack(2);
        stack.Push(100);
        stack.Push(200);
        stack.Pop();
        stack.Pop();
        Console.WriteLine(stack.IsEmpty());
    }
}

A True

B False

C 0

D Exception

💡 Hint

After popping all elements, the stack should be empty.

Both elements are popped, so top is -1 and IsEmpty() returns true.

❓ Predict Output

advanced

What error occurs when popping from an empty stack?

What will be the output or error when popping from an empty stack?

DSA C#

using System;

class Stack {
    private int[] items;
    private int top;
    private int maxSize;

    public Stack(int size) {
        maxSize = size;
        items = new int[maxSize];
        top = -1;
    }

    public int Pop() {
        if (!IsEmpty()) {
            return items[top--];
        }
        throw new InvalidOperationException("Stack is empty");
    }

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

class Program {
    static void Main() {
        Stack stack = new Stack(1);
        try {
            stack.Pop();
        } catch (Exception e) {
            Console.WriteLine(e.GetType().Name);
        }
    }
}

A InvalidOperationException

B IndexOutOfRangeException

C NullReferenceException

D No output

💡 Hint

Check the exception thrown when popping empty stack.

The code throws InvalidOperationException with message "Stack is empty" when popping empty stack.

🧠 Conceptual

expert

How many elements can a stack hold before it is full?

If a stack is implemented with an array of size N, how many elements can it hold before IsFull() returns true?

A Depends on the data type size

B N-1 elements

C N+1 elements

D N elements

💡 Hint

Think about array indexing and maximum capacity.

The stack can hold exactly N elements because the array size is N and top index goes from -1 to N-1.

Practice

1. What does the IsEmpty() method typically check in a stack data structure?

easy

A. If the stack has no elements inside

B. If the stack is full and cannot add more elements

C. If the stack has exactly one element

D. If the stack has more than one element

Solution

1. Step 1: Understand the purpose of IsEmpty()

   The IsEmpty() method checks whether the stack contains any elements or not.

2. Step 2: Interpret the meaning of empty stack

   An empty stack means it has zero elements inside, so no items to pop or peek.

3. Final Answer:

   If the stack has no elements inside -> Option A

4. Quick Check:

   IsEmpty() = true means stack is empty [OK]

Hint: Empty means zero elements inside the stack [OK]

Common Mistakes:

• Confusing empty with full
• Thinking IsEmpty checks for one element
• Assuming IsEmpty checks capacity

2. Which of the following is the correct C# syntax to check if a stack named myStack is full assuming it has a fixed size?

easy

A. if (myStack.Count == myStack.Capacity) { }

B. if (myStack.IsEmpty()) { }

C. if (myStack.Length == 0) { }

D. if (myStack.IsFull()) { }

Solution

1. Step 1: Understand stack properties in C#

   A stack with fixed size uses Count for current elements and Capacity for max size.

2. Step 2: Check if stack is full

   If Count equals Capacity, the stack is full and cannot add more elements.

3. Final Answer:

   if (myStack.Count == myStack.Capacity) { } -> Option A

4. Quick Check:

   Count == Capacity means full stack [OK]

Hint: Full means count equals capacity in fixed size stack [OK]

Common Mistakes:

• Using IsEmpty() to check full
• Checking Length property which stacks don't have
• Using IsFull() without defining it

3. Consider this C# code snippet:

Stack<int> stack = new Stack<int>(3);
stack.Push(10);
stack.Push(20);
stack.Push(30);
bool isFull = stack.Count == 3;
bool isEmpty = stack.Count == 0;
Console.WriteLine(isFull);
Console.WriteLine(isEmpty);

What will be the output?

medium

A. True\nTrue

B. True\nFalse

C. False\nTrue

D. False\nFalse

Solution

1. Step 1: Analyze stack operations

   Three elements (10, 20, 30) are pushed into a stack with capacity 3, so stack is full.

2. Step 2: Evaluate isFull and isEmpty values

   isFull = stack.Count == 3 is true; isEmpty = stack.Count == 0 is false.

3. Final Answer:

   True\nFalse -> Option B

4. Quick Check:

   Count=3 means full=true, empty=false [OK]

Hint: Count equals capacity means full; zero means empty [OK]

Common Mistakes:

• Assuming stack is empty after pushes
• Confusing isFull and isEmpty values
• Ignoring stack capacity

4. The following C# code tries to check if a stack is full but causes a compile error:

Stack<int> stack = new Stack<int>();
if (stack.IsFull()) {
    Console.WriteLine("Stack is full");
}

What is the error and how to fix it?

medium

A. Change Stack<int> to List<int>

B. Stack cannot be empty; remove the if condition

C. IsFull() method does not exist; use stack.Count == capacity instead

D. Use stack.IsEmpty() instead of IsFull()

Solution

1. Step 1: Identify the error

   The IsFull() method is not defined in C# Stack class, causing a compile error.

2. Step 2: Correct the check for full stack

   Use stack.Count == capacity to check if stack is full, since Stack has no IsFull() method.

3. Final Answer:

   IsFull() method does not exist; use stack.Count == capacity instead -> Option C

4. Quick Check:

   No IsFull() method in Stack class [OK]

Hint: Stack class has no IsFull(); check count vs capacity [OK]

Common Mistakes:

• Assuming IsFull() exists by default
• Using IsEmpty() to check full
• Changing data structure unnecessarily

5. You have a fixed size stack of capacity 5. After pushing 3 elements, you want to check if you can push 2 more without overflow. Which condition correctly checks this in C#?

hard

A. if (stack.Count - 2 >= 0) { /* safe to push */ }

B. if (stack.IsEmpty()) { /* safe to push */ }

C. if (stack.Count == 5) { /* safe to push */ }

D. if (stack.Count + 2 <= 5) { /* safe to push */ }

Solution

1. Step 1: Understand stack capacity and current count

   Stack capacity is 5, current count is 3, so 2 more pushes are possible if total does not exceed 5.

2. Step 2: Formulate condition to check safe push

   Check if current count plus 2 is less than or equal to capacity: stack.Count + 2 <= 5.

3. Final Answer:

   if (stack.Count + 2 <= 5) { /* safe to push */ } -> Option D

4. Quick Check:

   Count + pushes ≤ capacity means safe [OK]

Hint: Add pushes to count; compare with capacity [OK]

Common Mistakes:

• Using IsEmpty() to check push safety
• Checking count equals capacity incorrectly
• Subtracting pushes instead of adding