Check if Stack is Empty or Full in DSA Javascript - Time & Space Complexity

Time Complexity: Check if Stack is Empty or Full

O(1)

Understanding Time Complexity

We want to understand how fast we can check if a stack is empty or full.

This helps us know how much time these checks take as the stack size changes.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Stack {
  constructor(size) {
    this.size = size;
    this.items = [];
  }

  isEmpty() {
    return this.items.length === 0;
  }

  isFull() {
    return this.items.length === this.size;
  }
}
    

This code checks if the stack has no items or if it reached its maximum size.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Checking the length property of the array.
• How many times: Once per call to isEmpty or isFull.

How Execution Grows With Input

Checking the length does not depend on how many items are in the stack.

Input Size (n)	Approx. Operations
10	1
100	1
1000	1

Pattern observation: The number of operations stays the same no matter the stack size.

Final Time Complexity

Time Complexity: O(1)

This means checking if the stack is empty or full takes the same small amount of time regardless of stack size.

Common Mistake

[X] Wrong: "Checking if the stack is full or empty takes longer as the stack grows because it looks at all items."

[OK] Correct: The code only checks the length property, which is stored and accessed instantly, not by scanning all items.

Interview Connect

Knowing that simple checks like empty or full run instantly shows you understand efficient data structure operations.

Self-Check

"What if the stack was implemented using a linked list instead of an array? How would the time complexity of checking if it is full or empty change?"

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