Check if Stack is Empty or Full in DSA Typescript - 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 these checks affect the program speed as the stack grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Stack {
  private items: number[] = [];
  private maxSize: number;

  constructor(size: number) {
    this.maxSize = size;
  }

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

  isFull(): boolean {
    return this.items.length === this.maxSize;
  }
}
    

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 is a simple property access and does not depend on stack size.

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

Pattern observation: The number of operations stays the same no matter how big the stack is.

Final Time Complexity

Time Complexity: O(1)

This means checking if the stack is empty or full takes the same short 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 needs to look at all items."

[OK] Correct: The check only looks at the count of items, not each item, so it takes the same time no matter the stack size.

Interview Connect

Knowing that these checks are very fast helps you focus on more complex parts of stack operations during interviews.

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 empty or full change?"

Practice

1. What does the isEmpty() method check in a stack data structure?

easy

A. If the stack is full and cannot add more elements

B. If the stack has no elements inside

C. If the stack has exactly one element

D. If the stack has more than one element

Solution

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

   The isEmpty() method is designed to check whether the stack contains any elements or not.

2. Step 2: Interpret the meaning of empty stack

   An empty stack means it has zero elements inside, so isEmpty() returns true only when the stack is empty.

3. Final Answer:

   If the stack has no elements inside -> Option B

4. Quick Check:

   isEmpty() checks for empty stack = A [OK]

Hint: Empty means zero elements inside the stack [OK]

Common Mistakes:

• Confusing isEmpty() with isFull()
• Thinking isEmpty() checks for one element
• Assuming isEmpty() checks if stack is full

2. Which of the following is the correct TypeScript syntax to check if a stack is full when using an array with fixed size maxSize and current top index?

easy

A. if (top === maxSize - 1) { /* stack is full */ }

B. if (top === maxSize) { /* stack is full */ }

C. if (top > maxSize) { /* stack is full */ }

D. if (top < maxSize) { /* stack is full */ }

Solution

1. Step 1: Understand stack indexing

   In a fixed size stack using an array, top starts at -1 and increments by 1 for each push. The last valid index is maxSize - 1.

2. Step 2: Check condition for full stack

   The stack is full when top equals maxSize - 1, meaning no more space to add elements.

3. Final Answer:

   if (top === maxSize - 1) { /* stack is full */ } -> Option A

4. Quick Check:

   Full stack when top = maxSize - 1 [OK]

Hint: Stack full when top equals maxSize minus one [OK]

Common Mistakes:

• Using top === maxSize (off by one error)
• Checking top > maxSize (invalid index)
• Using top < maxSize (means not full)

3. Consider this TypeScript code for a stack with maxSize 3:

class Stack {
  maxSize = 3;
  top = -1;
  items: number[] = [];

  isFull() {
    return this.top === this.maxSize - 1;
  }

  push(item: number) {
    if (!this.isFull()) {
      this.top++;
      this.items[this.top] = item;
    }
  }
}

const stack = new Stack();
stack.push(10);
stack.push(20);
stack.push(30);
stack.push(40);
console.log(stack.items);

What will be printed?

medium

A. [40, 20, 30]

B. [10, 20, 30, 40]

C. [10, 20, 30]

D. []

Solution

1. Step 1: Trace push operations with isFull check

   Stack maxSize is 3, so top max is 2. Push 10: top=0, items[0]=10; Push 20: top=1, items[1]=20; Push 30: top=2, items[2]=30; Push 40: isFull() returns true (top=2), so push ignored.

2. Step 2: Final stack items array

   After all pushes, items array is [10, 20, 30]. The 4th push does not add 40.

3. Final Answer:

   [10, 20, 30] -> Option C

4. Quick Check:

   Stack full at 3 items, 4th push ignored [OK]

Hint: Push stops when stack is full, extra items ignored [OK]

Common Mistakes:

• Assuming push adds all items ignoring full check
• Thinking array grows beyond maxSize
• Confusing top index with array length

4. This TypeScript stack code tries to check if the stack is empty:

class Stack {
  top = -1;
  isEmpty() {
    return this.top === 0;
  }
}

What is wrong with this isEmpty() method?

medium

A. It should check if top is 1, not 0

B. It should check if top is less than 0

C. It should check if top is greater than 0

D. It should check if top is -1, not 0

Solution

1. Step 1: Understand top index for empty stack

   In stack implementation, top is -1 when stack is empty (no elements pushed yet).

2. Step 2: Identify incorrect condition

   The code checks top === 0, which means one element is present, so it wrongly returns true for non-empty stack.

3. Final Answer:

   It should check if top is -1, not 0 -> Option D

4. Quick Check:

   Empty stack means top = -1 [OK]

Hint: Empty stack top is -1, not zero [OK]

Common Mistakes:

• Checking top === 0 means stack has one element
• Using greater than or less than instead of equality
• Confusing empty with single element condition

5. You have a stack with maxSize 5 and current top at 3. You want to write a method canPush() that returns true only if the stack is not full and not empty. Which condition correctly implements this?

hard

A. return this.top > -1 && this.top < this.maxSize - 1;

B. return this.top >= 0 && this.top <= this.maxSize - 1;

C. return this.top !== -1 && this.top !== this.maxSize;

D. return this.top > 0 && this.top < this.maxSize;

Solution

1. Step 1: Define conditions for not empty and not full

   Not empty means top > -1 (at least one element). Not full means top < maxSize - 1 (space to add more).

2. Step 2: Combine conditions logically

   Both conditions must be true, so use logical AND: top > -1 && top < maxSize - 1.

3. Final Answer:

   return this.top > -1 && this.top < this.maxSize - 1; -> Option A

4. Quick Check:

   Not empty and not full = top > -1 and top < maxSize - 1 [OK]

Hint: Check top between -1 and maxSize-1 exclusive [OK]

Common Mistakes:

• Using >= or <= incorrectly allowing empty or full
• Using !== which can fail for boundary values
• Confusing maxSize with maxSize - 1