Check if Stack is Empty or Full in DSA Javascript - Build from Scratch

Check if Stack is Empty or Full

📖 Scenario: Imagine you have a stack of books on a shelf. You want to check if the shelf is empty or completely full before adding or removing books.

🎯 Goal: You will create a stack with a fixed size, then write code to check if the stack is empty or full.

📋 What You'll Learn

Create a stack array with exact elements

Create a variable for the maximum stack size

Write functions to check if the stack is empty or full

Print the results of these checks

💡 Why This Matters

🌍 Real World

Stacks are used in many places like undo features in text editors, browser history, and managing function calls.

💼 Career

Understanding stack operations is important for software development roles, especially those involving algorithms and system design.

1

Create the Stack Array

Create an array called stack with these exact elements: 10, 20, 30.

DSA Javascript

// Your code here

Hint

Use const stack = [10, 20, 30]; to create the stack array.

2

Set the Maximum Stack Size

Create a constant called maxSize and set it to 5.

DSA Javascript

const stack = [10, 20, 30];
// Your code here

Hint

Use const maxSize = 5; to set the maximum size of the stack.

3

Write Functions to Check if Stack is Empty or Full

Write two functions: isEmpty() that returns true if stack is empty, and isFull() that returns true if stack length equals maxSize.

DSA Javascript

const stack = [10, 20, 30];
const maxSize = 5;
// Your code here

Hint

Use stack.length to check the size of the stack inside the functions.

4

Print the Results of the Checks

Print the result of isEmpty() and isFull() functions using console.log.

DSA Javascript

const stack = [10, 20, 30];
const maxSize = 5;

function isEmpty() {
    return stack.length === 0;
}

function isFull() {
    return stack.length === maxSize;
}

// Your code here

Hint

Use console.log(isEmpty()); and console.log(isFull()); to print the results.

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