Check if Stack is Empty or Full in DSA Python

Mental Model

A stack is like a pile where you add or remove items only from the top. Checking if it is empty means no items are there, and checking if it is full means no more items can fit.

Analogy: Imagine a stack of plates in a cupboard. If there are no plates, the stack is empty. If the cupboard is full and can't hold more plates, the stack is full.

Top -> [ ] ← Bottom (empty stack)
Top -> [5] -> [3] -> [1] ← Bottom (partially filled stack)
Top -> [9] -> [8] -> [7] -> [6] -> [5] ← Bottom (full stack)

Dry Run Walkthrough

Input: stack capacity 3, current stack elements: [5, 3], check empty and full

Goal: Determine if the stack is empty or full at this moment

Step 1: Check if stack size is 0 to see if empty

Stack: 5 -> 3 -> null, size=2, capacity=3

Why: If size is 0, stack is empty; here size is 2, so not empty

Step 2: Check if stack size equals capacity to see if full

Stack: 5 -> 3 -> null, size=2, capacity=3

Why: If size equals capacity, stack is full; here size is 2, capacity 3, so not full

Result:

Stack: 5 -> 3 -> null
Empty? False
Full? False

Annotated Code

DSA Python

class Stack:
    def __init__(self, capacity):
        self.capacity = capacity
        self.items = []

    def is_empty(self):
        return len(self.items) == 0

    def is_full(self):
        return len(self.items) == self.capacity

    def push(self, item):
        if self.is_full():
            print("Stack is full, cannot push")
            return
        self.items.append(item)

    def __str__(self):
        return ' -> '.join(map(str, reversed(self.items))) + ' -> null'

# Driver code
stack = Stack(3)
stack.push(5)
stack.push(3)
print(stack)
print("Empty?", stack.is_empty())
print("Full?", stack.is_full())

return len(self.items) == 0

Check if stack has zero elements to determine emptiness

return len(self.items) == self.capacity

Check if stack size reached capacity to determine fullness

if self.is_full():

Prevent pushing if stack is already full

self.items.append(item)

Add new item to top of stack

Output

5 -> 3 -> null

Empty? False

Full? False

Complexity Analysis

Time: O(1) because checking length and comparing is a constant time operation

Space: O(n) where n is capacity, because stack stores up to n items

vs Alternative: Using a linked list stack would also have O(1) checks for empty but no fixed capacity, so no full check

Edge Cases

Empty stack

is_empty returns True, is_full returns False

DSA Python

return len(self.items) == 0

Stack with one element

is_empty returns False, is_full depends on capacity

DSA Python

return len(self.items) == self.capacity

Stack at full capacity

is_full returns True, push is blocked

DSA Python

if self.is_full():

When to Use This Pattern

When you need to control adding or removing items safely in a fixed-size container, check if the stack is empty or full to avoid errors.

Common Mistakes

Mistake: Checking if stack is empty by comparing to None instead of length zero
Fix: Use len(self.items) == 0 to check emptiness

Mistake: Not checking if stack is full before pushing, causing overflow
Fix: Always check is_full() before push to prevent overflow

Summary

Checks if a stack has no items or is at its maximum capacity.

Use when managing a stack with limited size to avoid errors.

Remember: empty means zero items, full means size equals capacity.

Practice

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

easy

A. If the stack has exactly one element

B. If the stack is full

C. If the stack has more than one element

D. If the stack has no elements

Solution

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

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

2. Step 2: Identify what empty means for a stack

   An empty stack means it has zero elements, so isEmpty() returns true if no elements are present.

3. Final Answer:

   If the stack has no elements -> Option D

4. Quick Check:

   Empty stack means no elements = true [OK]

Hint: Empty stack means zero elements inside [OK]

Common Mistakes:

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

2. Which of the following is the correct syntax to check if a stack named stack is full in Python assuming max size is stored in max_size and current size in top?

easy

A. if top == max_size: print('Stack is full')

B. if top > max_size: print('Stack is full')

C. if top < max_size: print('Stack is full')

D. if top != max_size: print('Stack is full')

Solution

1. Step 1: Understand stack full condition

   A stack is full when the current top index equals the maximum allowed size.

2. Step 2: Match condition with syntax

   The correct check is top == max_size to confirm fullness.

3. Final Answer:

   if top == max_size: print('Stack is full') -> Option A

4. Quick Check:

   Full stack when top equals max size [OK]

Hint: Full stack means top equals max size [OK]

Common Mistakes:

• Using greater than instead of equal
• Using less than for full check
• Using not equal instead of equal

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

class Stack:
    def __init__(self, max_size):
        self.stack = []
        self.max_size = max_size
    def isFull(self):
        return len(self.stack) == self.max_size
    def isEmpty(self):
        return len(self.stack) == 0

s = Stack(2)
s.stack.append(10)
s.stack.append(20)
print(s.isFull())
print(s.isEmpty())

medium

A. False\nTrue

B. True\nTrue

C. True\nFalse

D. False\nFalse

Solution

1. Step 1: Check stack contents after append

   Two elements (10, 20) are added, so length is 2 which equals max_size.

2. Step 2: Evaluate isFull and isEmpty

   isFull() returns True because length equals max_size; isEmpty() returns False because stack is not empty.

3. Final Answer:

   True False -> Option C

4. Quick Check:

   Stack full = True, empty = False [OK]

Hint: Full if length equals max size; empty if length zero [OK]

Common Mistakes:

• Confusing isFull and isEmpty return values
• Ignoring stack length after append
• Assuming stack is empty after append

4. Find the error in the following code that checks if a stack is empty:

class Stack:
    def __init__(self):
        self.stack = []
    def isEmpty(self):
        if self.stack == 0:
            return True
        else:
            return False

s = Stack()
print(s.isEmpty())

medium

A. Missing return statement in isEmpty

B. Comparing list to integer zero causes error

C. Stack initialization is incorrect

D. Print statement syntax is wrong

Solution

1. Step 1: Analyze the isEmpty condition

   The code compares self.stack == 0, but self.stack is a list, not a number.

2. Step 2: Identify correct way to check empty list

   To check if list is empty, use len(self.stack) == 0 or simply not self.stack.

3. Final Answer:

   Comparing list to integer zero causes error -> Option B

4. Quick Check:

   List cannot be compared to number 0 [OK]

Hint: Check list emptiness with length or not operator [OK]

Common Mistakes:

• Comparing list directly to 0
• Forgetting list length check
• Using wrong comparison operator

5. You have a stack with max size 3. After pushing 3 elements, you pop one element and then check if the stack is full or empty. What will be the correct output of isFull() and isEmpty() methods?

class Stack:
    def __init__(self, max_size):
        self.stack = []
        self.max_size = max_size
    def push(self, val):
        if len(self.stack) < self.max_size:
            self.stack.append(val)
    def pop(self):
        if not self.isEmpty():
            return self.stack.pop()
    def isFull(self):
        return len(self.stack) == self.max_size
    def isEmpty(self):
        return len(self.stack) == 0

s = Stack(3)
s.push(1)
s.push(2)
s.push(3)
s.pop()
print(s.isFull())
print(s.isEmpty())

hard

A. False\nFalse

B. True\nFalse

C. False\nTrue

D. True\nTrue

Solution

1. Step 1: Track stack size after operations

   Initially push 3 elements, stack size = 3 (full). After pop, size reduces to 2.

2. Step 2: Evaluate isFull and isEmpty

   Since size is 2 and max_size is 3, isFull() returns False. Stack is not empty, so isEmpty() returns False.

3. Final Answer:

   False False -> Option A

4. Quick Check:

   Stack size 2 < max size 3, not empty [OK]

Hint: Pop reduces size; full only if size equals max [OK]

Common Mistakes:

• Assuming stack is still full after pop
• Assuming stack is empty after pop
• Ignoring size changes after pop