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

Overview - Check if Stack is Empty or Full

What is it?

A stack is a collection where you add and remove items in a last-in, first-out order. Checking if a stack is empty means seeing if there are no items inside. Checking if it is full means seeing if it has reached its maximum capacity and cannot hold more items. These checks help manage the stack safely during use.

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 one, causing errors or crashes. This can lead to unexpected behavior or system failures. These checks keep programs stable and predictable, especially when stacks have size limits.

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 how stacks are used in algorithms like expression evaluation or backtracking.

Mental Model

Core Idea

A stack is empty when it has no items and full when it has reached its set limit, and checking these states prevents errors during adding or removing items.

Think of it like...

Imagine a stack of plates in a kitchen. If there are no plates, the stack is empty and you can't take one. If the stack is piled up to the shelf's limit, it's full and you can't add more plates without risking a fall.

Stack (top)
┌─────┐
│     │ <- Empty if no boxes here
│     │
│     │
│     │
└─────┘
Full when all slots are filled up to the top.

Build-Up - 7 Steps

1

Foundation

What is a Stack Data Structure

Concept: Introduce the basic idea of a stack and its LIFO behavior.

A stack is like a pile where you add items on top and remove items from the top only. The last item you put in is the first one you take out. This is called Last-In, First-Out (LIFO).

Result

You understand that stacks only allow adding or removing from one end, the top.

Understanding the LIFO nature of stacks is key to grasping why checking empty or full states matters.

2

Foundation

Stack Size and Capacity Basics

Concept: Explain that stacks can have a size limit and how size relates to fullness.

Stacks can be limited in size, meaning they can hold only a fixed number of items. The current number of items is the size. When size is zero, the stack is empty. When size equals capacity, the stack is full.

Result

You know how to tell if a stack is empty or full by comparing size to zero or capacity.

Knowing the size and capacity relationship helps prevent errors like adding too many items or removing from an empty stack.

3

Intermediate

Checking if Stack is Empty in Code

🤔Before reading on: do you think checking if a stack is empty means comparing size to zero or capacity? Commit to your answer.

Concept: Learn how to write a function that returns true if the stack has no items.

function isEmpty(stack) { return stack.size === 0; } // Example: const stack = { size: 0, capacity: 5 }; console.log(isEmpty(stack)); // true

Result

The function returns true when the stack has zero items, false otherwise.

Understanding that empty means size zero is the simplest and safest way to check stack emptiness.

4

Intermediate

Checking if Stack is Full in Code

🤔Before reading on: do you think checking if a stack is full means size equals capacity or size less than capacity? Commit to your answer.

Concept: Learn how to write a function that returns true if the stack cannot hold more items.

function isFull(stack) { return stack.size === stack.capacity; } // Example: const stack = { size: 5, capacity: 5 }; console.log(isFull(stack)); // true

Result

The function returns true when the stack size equals its capacity, false otherwise.

Knowing that full means size equals capacity prevents adding items beyond the stack's limit.

5

Intermediate

Using Empty and Full Checks in Stack Operations

🤔Before reading on: do you think push should check if stack is full or empty before adding? Commit to your answer.

Concept: Show how to use empty and full checks to safely add or remove items.

function push(stack, item) { if (isFull(stack)) { console.log('Stack is full, cannot add item'); return; } stack.items.push(item); stack.size++; } function pop(stack) { if (isEmpty(stack)) { console.log('Stack is empty, cannot remove item'); return null; } stack.size--; return stack.items.pop(); }

Result

Push adds items only if not full; pop removes items only if not empty, preventing errors.

Using these checks in operations ensures the stack stays in a valid state and avoids runtime errors.

6

Advanced

Handling Dynamic Stack Capacity

🤔Before reading on: do you think a stack can grow beyond its initial capacity automatically? Commit to your answer.

Concept: Explain how some stacks resize dynamically and how empty/full checks adapt.

Some stacks start with a fixed capacity but grow when full by creating a bigger storage and copying items. In this case, isFull may trigger resizing instead of blocking push. Example: function pushDynamic(stack, item) { if (isFull(stack)) { stack.capacity *= 2; // double capacity // copy items to new storage (not shown here) } stack.items.push(item); stack.size++; }

Result

The stack can hold more items by resizing, so isFull triggers growth instead of failure.

Understanding dynamic resizing shows that 'full' can be a temporary state, enabling flexible stacks.

7

Expert

Subtle Edge Cases in Empty and Full Checks

🤔Before reading on: do you think a stack with negative size or capacity zero can be empty or full? Commit to your answer.

Concept: Explore uncommon cases like zero or negative capacity and how checks behave.

If capacity is zero, the stack is always full and empty at the same time logically, which is contradictory. Negative sizes or capacities are invalid and should be prevented. Robust checks include: function isEmptySafe(stack) { return stack.size <= 0; } function isFullSafe(stack) { return stack.capacity > 0 && stack.size >= stack.capacity; }

Result

Safe checks handle invalid or edge values gracefully, avoiding bugs or crashes.

Knowing these edge cases helps build reliable stack implementations that don't break in unusual situations.

Under the Hood

Internally, a stack is often an array or linked list with a pointer or counter tracking the current top position or size. Checking empty means verifying if this pointer is at the start (zero). Checking full means comparing the pointer to the maximum allowed size. These checks are simple comparisons but critical to avoid accessing invalid memory or data.

Why designed this way?

Stacks are designed with simple size tracking for efficiency and safety. Early computer memory was limited, so fixed-size stacks were common. The empty/full checks prevent overflow (adding too many items) and underflow (removing from empty), which can cause crashes or data corruption. Dynamic resizing was added later to improve flexibility.

Stack Structure
┌───────────────┐
│   Capacity    │
│     (max)     │
├───────────────┤
│   Items[]     │
│  ┌─────────┐  │
│  │  Top ->  │  │
│  └─────────┘  │
│   Size (top)  │
└───────────────┘

Empty check: size === 0
Full check: size === capacity

Myth Busters - 4 Common Misconceptions

Quick: Is a stack full when it has one empty slot left? Commit to yes or no.

Common Belief: A stack is full only when it has no empty slots left, so one empty slot means not full.

Reality: Correct, a stack is full only when size equals capacity, meaning no empty slots remain.

Why it matters: Misunderstanding this can cause attempts to add items when the stack is actually full, leading to overflow errors.

Quick: Can you pop an item from a stack that is full? Commit to yes or no.

Common Belief: If a stack is full, you cannot pop items because it's too full to remove anything.

Reality: You can always pop items from a full stack because full means it has maximum items, so removal is possible.

Why it matters: Confusing full with inability to remove causes incorrect logic and missed opportunities to free space.

Quick: Does an empty stack have a size of -1? Commit to yes or no.

Common Belief: Some think empty stacks have size -1 to indicate no items.

Reality: Stacks use size 0 to indicate empty; negative sizes are invalid and cause errors.

Why it matters: Using negative sizes breaks stack logic and can cause crashes or incorrect behavior.

Quick: Is it safe to skip empty/full checks if you trust your code? Commit to yes or no.

Common Belief: If the code is well written, you don't need to check if the stack is empty or full before operations.

Reality: Skipping these checks risks runtime errors if assumptions fail, so checks are essential for safety.

Why it matters: Ignoring checks leads to bugs that are hard to find and fix, especially in large or complex programs.

Expert Zone

1

Empty and full checks can be optimized away in some low-level systems when usage patterns guarantee safety, but this requires careful proof.

2

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

3

Dynamic stacks may temporarily report full during resizing, so operations must handle this transient state gracefully.

When NOT to use

Fixed-size stack empty/full checks are not suitable when stack size must grow dynamically without limits. In such cases, use dynamic arrays or linked lists that resize automatically and rely on capacity checks only for performance tuning.

Production Patterns

In real systems, stacks often use empty/full checks combined with error handling or automatic resizing. For example, web browsers use stacks for navigation history with dynamic resizing, while embedded systems use fixed stacks with strict empty/full checks to avoid memory overflow.

Connections

Queue Data Structure

Opposite access pattern (FIFO vs LIFO) but similar empty/full checks

Understanding stack empty/full checks helps grasp queue capacity management, as both need safe boundary checks despite different item order.

Memory Management

Stacks are used to manage function calls and local variables in memory with empty/full limits

Knowing stack empty/full states aids understanding of call stack overflow errors and safe memory usage in programs.

Inventory Management in Warehouses

Both track capacity limits and empty states to avoid overstocking or running out

Recognizing how stacks check empty/full mirrors real-world inventory control, showing how data structures model practical problems.

Common Pitfalls

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

Wrong approach:

function pop(stack) {
return stack.items.pop(); // no empty check
}

Correct approach:

function pop(stack) {
if (isEmpty(stack)) {
console.log('Stack is empty');
return null;
}
return stack.items.pop();
}

Root cause:

Assuming the stack always has items leads to runtime errors when popping empty stacks.

#2 Pushing items without checking if the stack is full.

Wrong approach:

function push(stack, item) {
stack.items.push(item); // no full check
stack.size++;
}

Correct approach:

function push(stack, item) {
if (isFull(stack)) {
console.log('Stack is full');
return;
}
stack.items.push(item);
stack.size++;
}

Root cause:

Ignoring capacity limits causes overflow and corrupts stack data.

#3 Using size -1 to indicate empty stack.

Wrong approach:

const stack = { size: -1, capacity: 5, items: [] };

Correct approach:

const stack = { size: 0, capacity: 5, items: [] };

Root cause:

Misunderstanding size semantics leads to invalid stack states and logic errors.

Key Takeaways

A stack is empty when it has zero items and full when its size equals its capacity.

Checking if a stack is empty or full prevents errors like underflow and overflow during push and pop operations.

Empty and full checks are simple comparisons but critical for safe stack usage in all programs.

Dynamic stacks can resize when full, changing the meaning of 'full' from a hard limit to a trigger for growth.

Robust stack implementations handle edge cases like zero or negative capacity to avoid unexpected bugs.

Practice

1. What does it mean when a stack is empty?

easy

A. The stack has one element.

B. The stack has reached its maximum size.

C. There are no elements in the stack.

D. The stack is full and cannot add more elements.

Solution

1. Step 1: Understand the stack empty condition

   A stack is empty when it contains no elements inside it.

2. Step 2: Compare with other options

   Options about full stack or having elements do not describe empty stack.

3. Final Answer:

   There are no elements in the stack. -> Option C

4. Quick Check:

   Empty stack means no elements [OK]

Hint: Empty stack means zero elements inside [OK]

Common Mistakes:

• Confusing empty with full
• Thinking empty means one element
• Mixing empty with partially filled

2. Which of the following JavaScript code snippets correctly checks if a stack array stack is empty?

easy

A. if (stack.length === 0) { /* empty */ }

B. if (stack === null) { /* empty */ }

C. if (stack.length > 0) { /* empty */ }

D. if (stack.size === 0) { /* empty */ }

Solution

1. Step 1: Check correct property for array length

   JavaScript arrays use length property to get number of elements.

2. Step 2: Verify condition for empty stack

   Empty means length is zero, so stack.length === 0 is correct.

3. Final Answer:

   if (stack.length === 0) { /* empty */ } -> Option A

4. Quick Check:

   Use length property to check empty [OK]

Hint: Use stack.length === 0 to check empty [OK]

Common Mistakes:

• Using null instead of length
• Using size property (not for arrays)
• Checking length > 0 for empty

3. Consider this JavaScript stack implementation with max size 3:

const stack = [];
const maxSize = 3;
stack.push(10);
stack.push(20);
stack.push(30);
const isFull = stack.length === maxSize;
const isEmpty = stack.length === 0;
console.log(isFull, isEmpty);

What will be printed?

medium

A. false false

B. false true

C. true true

D. true false

Solution

1. Step 1: Trace stack push operations

   Three elements (10, 20, 30) are pushed, so stack length is 3.

2. Step 2: Evaluate isFull and isEmpty

   isFull = stack.length === maxSize -> 3 === 3 -> true; isEmpty = stack.length === 0 -> 3 === 0 -> false.

3. Final Answer:

   true false -> Option D

4. Quick Check:

   Stack full = true, empty = false [OK]

Hint: Stack full if length equals max size [OK]

Common Mistakes:

• Confusing isFull and isEmpty
• Forgetting to update length after push
• Assuming stack is empty after pushes

4. Find the error in this code that checks if a stack is full:

const stack = [1, 2, 3];
const maxSize = 3;
function isStackFull() {
  if (stack.length = maxSize) {
    return true;
  } else {
    return false;
  }
}

medium

A. Using assignment (=) instead of comparison (===) in if condition.

B. maxSize should be stack.length, not a constant.

C. Function should return stack.length instead of boolean.

D. Stack array should be empty to check if full.

Solution

1. Step 1: Identify the if condition mistake

   The condition uses single equals = which assigns value instead of comparing.

2. Step 2: Correct comparison operator

   It should use === to compare stack length with maxSize.

3. Final Answer:

   Using assignment (=) instead of comparison (===) in if condition. -> Option A

4. Quick Check:

   Use === for comparison, not = [OK]

Hint: Use === for comparison, not = [OK]

Common Mistakes:

• Using = instead of ===
• Confusing maxSize with stack length
• Returning wrong type from function

5. You have a stack with max size 5. After pushing 3 elements, you want to check if the stack is full or empty and print the status as a string: "Full", "Empty", or "Partial". Which code correctly implements this?

hard

A. if (stack.length > 5) { console.log('Full'); } else if (stack.length < 0) { console.log('Empty'); } else { console.log('Partial'); }

B. if (stack.length === 5) { console.log('Full'); } else if (stack.length === 0) { console.log('Empty'); } else { console.log('Partial'); }

C. if (stack.length === 0) { console.log('Full'); } else if (stack.length === 5) { console.log('Empty'); } else { console.log('Partial'); }

D. if (stack.length >= 5) { console.log('Empty'); } else if (stack.length <= 0) { console.log('Full'); } else { console.log('Partial'); }

Solution

1. Step 1: Check conditions for full and empty stack

   Full means length equals max size (5), empty means length zero.

2. Step 2: Use else for partial stack

   If neither full nor empty, stack is partially filled.

3. Final Answer:

   if (stack.length === 5) { console.log('Full'); } else if (stack.length === 0) { console.log('Empty'); } else { console.log('Partial'); } -> Option B

4. Quick Check:

   Check length === maxSize for full, === 0 for empty [OK]

Hint: Check length === maxSize for full, === 0 for empty [OK]

Common Mistakes:

• Using wrong comparison operators
• Swapping full and empty conditions
• Checking length > maxSize or < 0