Check if Stack is Empty or Full in DSA Java - Deep Dive

Overview - Check if Stack is Empty or Full

What is it?

A stack is a collection where elements are added and removed in a last-in, first-out order. Checking if a stack is empty means seeing if there are no elements inside it. Checking if a stack is full means seeing if it has reached its maximum capacity and cannot hold more elements. These checks help control how we use the stack safely.

Why it matters

Without knowing if a stack is empty or full, programs might try to remove items from an empty stack or add items to a full stack, causing errors or crashes. This can lead to unexpected behavior or system failures. These checks ensure programs run smoothly and data is handled correctly.

Where it fits

Before learning this, you should understand what a stack is and how it works. After this, you can learn about stack operations like push and pop, and then explore more complex data structures like queues or linked lists.

Mental Model

Core Idea

A stack is empty when it has no items, and full when it cannot hold any more items.

Think of it like...

Imagine a stack of plates: if there are no plates, the stack is empty; if the stack reaches the top shelf, it is full and cannot hold more plates.

Stack (top at the right):
┌─────┐
│     │ <- empty slot
│  3  │
│  2  │
│  1  │
└─────┘

Empty check: Is top pointing below first plate?
Full check: Is top pointing at last slot?

Build-Up - 7 Steps

1

Foundation

Understanding Stack Basics

Concept: Learn what a stack is and how it stores items in order.

A stack stores items one on top of another. You add items with 'push' and remove with 'pop'. The last item added is the first removed. The stack has a top position that shows where the last item is.

Result

You know how items are arranged and how the top changes with push/pop.

Understanding the top position is key to knowing if the stack has items or space.

2

Foundation

Stack Capacity and Limits

Concept: Stacks have a fixed size or capacity that limits how many items they can hold.

A stack can only hold a certain number of items, called its capacity. If you try to add more than this, the stack is full and cannot accept new items. If there are no items, the stack is empty.

Result

You understand that stacks have boundaries that must be respected.

Knowing capacity helps prevent errors when adding or removing items.

3

Intermediate

Checking if Stack is Empty

🤔Before reading on: do you think checking if a stack is empty means looking at the top position or counting all items? Commit to your answer.

Concept: Learn how to check if the stack has no items by looking at the top position.

If the top position is -1 (or below the first index), it means no items are in the stack. This is how we check if the stack is empty quickly without counting all items.

Result

You can tell if the stack is empty by checking if top == -1.

Checking the top index is a fast way to know if the stack is empty without scanning all elements.

4

Intermediate

Checking if Stack is Full

🤔Before reading on: do you think a stack is full when top equals capacity or when top is less than capacity? Commit to your answer.

Concept: Learn how to check if the stack has reached its maximum capacity by comparing top with size limit.

If the top position equals capacity - 1, the stack is full. This means no more items can be added. This check prevents pushing beyond the stack's limit.

Result

You can tell if the stack is full by checking if top == capacity - 1.

Knowing the top index relative to capacity prevents overflow errors.

5

Intermediate

Java Code for Empty and Full Checks

Concept: See how to implement empty and full checks in Java code for a stack.

class Stack { private int[] items; private int top = -1; private int capacity; public Stack(int size) { capacity = size; items = new int[capacity]; } public boolean isEmpty() { return top == -1; } public boolean isFull() { return top == capacity - 1; } public void push(int value) { items[++top] = value; } } // Usage example: Stack stack = new Stack(3); System.out.println(stack.isEmpty()); // true stack.push(10); System.out.println(stack.isFull()); // false

Result

The methods correctly return true or false for empty and full states.

Implementing these checks as methods makes stack usage safer and clearer.

6

Advanced

Handling Edge Cases in Stack Checks

🤔Before reading on: do you think an empty stack can also be full at the same time? Commit to your answer.

Concept: Understand special cases like empty and full states and how to avoid confusion.

An empty stack means top == -1, full means top == capacity - 1. These states cannot happen at the same time. Properly initializing top and updating it on push/pop keeps these checks reliable.

Result

You avoid bugs where stack state is misreported.

Clear separation of empty and full states prevents logical errors in stack operations.

7

Expert

Dynamic Stacks and Empty/Full Checks

🤔Before reading on: do you think dynamic stacks need a full check? Commit to your answer.

Concept: Explore how stacks that grow dynamically change the meaning of 'full'.

Dynamic stacks use resizable arrays or linked lists, so they don't have a fixed capacity. The 'full' check is replaced by memory availability checks or resizing logic. The empty check remains the same (top == -1 or null).

Result

You understand that full checks depend on stack implementation.

Knowing how implementation affects empty/full checks helps design flexible and efficient stacks.

Under the Hood

Internally, a stack uses an array and a 'top' index to track the last added item. The 'top' starts at -1 when empty. When pushing, 'top' increases; when popping, it decreases. Checking empty means seeing if 'top' is -1. Checking full means seeing if 'top' reached the last array index (capacity - 1).

Why designed this way?

This design uses simple integer tracking for fast checks without scanning the whole stack. Arrays provide quick access but fixed size, so full checks prevent overflow. This approach balances speed and safety.

Stack Array:
Index:  0    1    2    3    4
Value: [10] [20] [30] [   ] [   ]
Top -> index 2

Empty check: top == -1?
Full check: top == capacity - 1 (4)?

Myth Busters - 3 Common Misconceptions

Quick: Can a stack be both empty and full at the same time? Commit to yes or no.

Common Belief: Some think a stack can be empty and full simultaneously if it is reset or corrupted.

Reality: A stack cannot be empty and full at the same time; these are mutually exclusive states defined by the top index.

Why it matters: Believing this can cause confusion in logic and lead to bugs where operations behave unpredictably.

Quick: Is counting all items the best way to check if a stack is empty? Commit to yes or no.

Common Belief: Some believe you must count all elements to know if the stack is empty.

Reality: Checking the top index is enough and much faster than counting all items.

Why it matters: Counting wastes time and resources, especially for large stacks, slowing down programs.

Quick: Does a dynamic stack need a 'full' check like a fixed stack? Commit to yes or no.

Common Belief: Many think dynamic stacks still need a full check like fixed-size stacks.

Reality: Dynamic stacks resize or use linked nodes, so they don't have a fixed full state; full checks are replaced by memory or resizing logic.

Why it matters: Misapplying fixed stack logic to dynamic stacks can cause unnecessary errors or inefficient code.

Expert Zone

1

The 'top' index can be implemented differently (e.g., pointing to next free slot vs last filled slot), affecting empty/full checks subtly.

2

In concurrent environments, empty/full checks must be atomic to avoid race conditions causing incorrect states.

3

Some stack implementations use sentinel values or flags to optimize empty/full checks beyond simple index comparisons.

When NOT to use

Fixed-size stacks with empty/full checks are not suitable when data size is unpredictable or very large; use dynamic stacks or linked lists instead.

Production Patterns

In real systems, stacks often include empty/full checks inside push/pop methods to prevent errors. Dynamic resizing stacks use these checks to trigger array expansion. Embedded systems use fixed stacks with strict empty/full checks for memory safety.

Connections

Queue Data Structure

Queues also have empty/full states but use first-in, first-out order instead of last-in, first-out.

Understanding empty/full checks in stacks helps grasp similar checks in queues, highlighting how data order affects management.

Memory Management

Stack full checks relate to memory limits and overflow prevention in program execution stacks.

Knowing stack capacity and full checks connects to understanding how programs avoid crashing by managing memory carefully.

Inventory Management

Checking if a stack is empty or full is like checking if a warehouse shelf is empty or full.

This cross-domain link shows how simple state checks help manage resources efficiently in both computing and real-world logistics.

Common Pitfalls

#1 Trying to pop from an empty stack without checking.

Wrong approach:

if (top >= 0) {
int item = stack[top--];
} else {
// no check, just pop
int item = stack[top--];
}

Correct approach:

if (top == -1) {
System.out.println("Stack is empty, cannot pop.");
} else {
int item = stack[top--];
}

Root cause:

Not checking empty state leads to accessing invalid positions causing errors.

#2 Pushing onto a full stack without checking.

Wrong approach:

stack[++top] = newItem; // no full check

Correct approach:

if (top == capacity - 1) {
System.out.println("Stack is full, cannot push.");
} else {
stack[++top] = newItem;
}

Root cause:

Ignoring full check causes overflow and data corruption.

#3 Using top == capacity as full check instead of top == capacity - 1.

Wrong approach:

boolean isFull() {
return top == capacity;
}

Correct approach:

boolean isFull() {
return top == capacity - 1;
}

Root cause:

Off-by-one error misunderstanding array indexing.

Key Takeaways

A stack is empty when its top index is -1, meaning no items are stored.

A stack is full when its top index reaches capacity minus one, meaning no more items can be added.

Checking empty and full states prevents errors like underflow and overflow during stack operations.

Implementing these checks as simple methods makes stack usage safe and efficient.

Dynamic stacks change the meaning of full, relying on resizing rather than fixed capacity.

Practice

1. What does the isEmpty() method in a stack typically check?

easy

A. If the stack has exactly one element

B. If the stack is full

C. If the stack has no elements

D. If the stack is initialized

Solution

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

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

2. Step 2: Identify the condition checked

   If the stack has no elements, it is empty, so isEmpty() returns true.

3. Final Answer:

   If the stack has no elements -> Option C

4. Quick Check:

   Empty stack means no elements = true [OK]

Hint: Empty means zero elements in stack [OK]

Common Mistakes:

• Confusing isEmpty() with isFull()
• Thinking isEmpty() checks for one element
• Assuming isEmpty() checks initialization

2. Which of the following is the correct syntax to check if a stack named stack is full in Java?

easy

A. stack.isEmpty();

B. stack.isFull();

C. stack.full();

D. stack.isFilled();

Solution

1. Step 1: Identify the standard method name for full check

   In stack implementations, the method to check if the stack is full is usually named isFull().

2. Step 2: Match the correct syntax

   The correct syntax to call this method on a stack object named stack is stack.isFull();.

3. Final Answer:

   stack.isFull(); -> Option B

4. Quick Check:

   Method to check full = isFull() [OK]

Hint: Full check method is isFull() [OK]

Common Mistakes:

• Using isEmpty() to check full
• Using non-existent methods like full()
• Misspelling method names

3. What will be the output of the following Java code?

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

  boolean isFull() {
    return top == maxSize - 1;
  }

  boolean isEmpty() {
    return top == -1;
  }

  void push(int val) {
    if (!isFull()) {
      arr[++top] = val;
      System.out.println("Pushed " + val);
    } else {
      System.out.println("Stack is full");
    }
  }
}

public class Main {
  public static void main(String[] args) {
    Stack stack = new Stack();
    stack.push(10);
    stack.push(20);
    stack.push(30);
    stack.push(40);
  }
}

medium

A. Pushed 10
Pushed 20
Pushed 30
Stack is full

B. Pushed 10
Pushed 20
Pushed 30
Pushed 40

C. Stack is full
Stack is full
Stack is full
Stack is full

D. Pushed 10
Pushed 20
Stack is full
Stack is full

Solution

1. Step 1: Trace push operations and stack state

   Initially, top = -1. Each push increments top and adds value if stack not full. Max size is 3, so max top index is 2.

2. Step 2: Check each push call

   Push 10: top becomes 0, prints "Pushed 10".
   Push 20: top becomes 1, prints "Pushed 20".
   Push 30: top becomes 2, prints "Pushed 30".
   Push 40: top is 2 (full), so prints "Stack is full".

3. Final Answer:

   Pushed 10 Pushed 20 Pushed 30 Stack is full -> Option A

4. Quick Check:

   Stack max size 3, 4th push fails [OK]

Hint: Stack full when top == maxSize-1 [OK]

Common Mistakes:

• Assuming push always succeeds
• Ignoring top index limits
• Confusing isEmpty() with isFull()

4. Find the error in this stack implementation snippet that checks if the stack is empty:

public boolean isEmpty() {
  if (top == 0) {
    return true;
  } else {
    return false;
  }
}

medium

A. No error, the code is correct

B. The method should return false when top == 0

C. The method should check if top == maxSize

D. The condition should be top == -1 to check empty

Solution

1. Step 1: Understand stack empty condition

   In stack, empty means no elements pushed, so top is usually -1.

2. Step 2: Identify incorrect condition

   The code checks top == 0, which means one element is present, so it is wrong for empty check.

3. Final Answer:

   The condition should be top == -1 to check empty -> Option D

4. Quick Check:

   Empty stack top = -1 [OK]

Hint: Empty stack top is -1, not 0 [OK]

Common Mistakes:

• Checking top == 0 for empty
• Confusing full and empty conditions
• Returning wrong boolean values

5. You have a stack with max size 5 and current top = 3. Which of the following statements is true about the stack's state?

hard

A. The stack is neither full nor empty

B. The stack is empty

C. The stack is full

D. The stack has exactly 5 elements

Solution

1. Step 1: Understand stack indexing and size

   Stack max size is 5, so valid top indices are 0 to 4. top = 3 means 4 elements are present (indices 0,1,2,3).

2. Step 2: Determine if stack is full or empty

   Full means top == maxSize - 1 which is 4 here, so not full.
   Empty means top == -1, so not empty.
   Therefore, stack is neither full nor empty.

3. Final Answer:

   The stack is neither full nor empty -> Option A

4. Quick Check:

   top=3, maxSize=5 means partial fill [OK]

Hint: Full if top = maxSize-1, empty if top = -1 [OK]

Common Mistakes:

• Assuming top=3 means full
• Confusing top index with element count
• Thinking top=3 means empty