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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after these stack operations?

Consider a stack with a maximum size of 3. We perform these operations in order:
push(10), push(20), pop(), push(30), push(40), push(50).
What is the printed stack content after these operations?

DSA Javascript

class Stack {
  constructor(maxSize) {
    this.items = [];
    this.maxSize = maxSize;
  }
  push(element) {
    if (this.items.length < this.maxSize) {
      this.items.push(element);
    }
  }
  pop() {
    if (this.items.length > 0) {
      return this.items.pop();
    }
    return null;
  }
  print() {
    console.log(this.items.join(' -> ') + ' -> null');
  }
}

const stack = new Stack(3);
stack.push(10);
stack.push(20);
stack.pop();
stack.push(30);
stack.push(40);
stack.push(50);
stack.print();

A 20 -> 30 -> 40 -> null

B 10 -> 20 -> 30 -> null

C 10 -> 30 -> 40 -> null

D 30 -> 40 -> 50 -> null

💡 Hint

Remember the stack size limit and that push does nothing if full.

After pushing 10 and 20, stack is [10,20]. Pop removes 20, stack is [10]. Push 30 and 40 add elements, stack is [10,30,40]. Push 50 is ignored because stack is full.

❓ Predict Output

intermediate

What does this code print about stack emptiness?

Given this stack code, what is the output after these operations?
push(5), pop(), isEmpty(), push(7), isEmpty()

DSA Javascript

class Stack {
  constructor() {
    this.items = [];
  }
  push(element) {
    this.items.push(element);
  }
  pop() {
    if (this.items.length === 0) return null;
    return this.items.pop();
  }
  isEmpty() {
    return this.items.length === 0;
  }
}

const stack = new Stack();
stack.push(5);
stack.pop();
console.log(stack.isEmpty());
stack.push(7);
console.log(stack.isEmpty());

A

false
true

B

false
false

C

true
true

D

true
false

💡 Hint

Check when the stack becomes empty after pop.

After pushing 5 and popping it, stack is empty so isEmpty() returns true. After pushing 7, stack is not empty so isEmpty() returns false.

🧠 Conceptual

advanced

Which condition correctly checks if a stack is full?

Assuming a stack implemented with an array and a max size, which condition correctly checks if the stack is full?

A stack.length > maxSize

B stack.length === maxSize

C stack.length < maxSize

D stack.length !== maxSize

💡 Hint

Full means no more elements can be added without exceeding max size.

The stack is full exactly when its length equals the max size. Greater than max size is invalid state.

❓ Predict Output

advanced

What error does this stack code raise?

What error occurs when calling pop() on an empty stack in this code?

DSA Javascript

class Stack {
  constructor() {
    this.items = [];
  }
  pop() {
    return this.items.pop().toString();
  }
}

const stack = new Stack();
stack.pop();

A TypeError: Cannot read property 'toString' of undefined

B ReferenceError: pop is not defined

C SyntaxError: Unexpected token

D No error, returns 'undefined'

💡 Hint

What does pop() return if the array is empty?

pop() returns undefined on empty array, calling toString() on undefined causes TypeError.

🧠 Conceptual

expert

How to efficiently check if a stack is empty or full in O(1)?

You have a stack implemented with an array and a max size. Which approach ensures checking if the stack is empty or full takes constant time O(1)?

A Keep a count variable updated on push/pop and compare with max size or zero

B Traverse the array each time to count elements

C Use a loop to check if any element is undefined

D Check if the last element is null

💡 Hint

Avoid scanning the whole array every time.

Maintaining a count variable updated on each push/pop allows O(1) checks for empty/full by comparing count to zero or max size.

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