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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after pushing elements to the stack?

Consider a stack with a maximum size of 3. We push elements 10, 20, and 30 in order. What is the printed state of the stack after these operations?

DSA Typescript

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

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

  push(element: number): void {
    if (this.items.length < this.maxSize) {
      this.items.push(element);
    }
  }

  print(): void {
    console.log(this.items.join(' -> ') + ' -> null');
  }
}

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

A 30 -> 20 -> 10 -> null

B Stack is empty

C 10 -> 20 -> null

D 10 -> 20 -> 30 -> null

💡 Hint

Remember that push adds elements to the top, but print shows from bottom to top in this implementation.

The stack stores elements in an array. Pushing 10, 20, 30 adds them in order. Printing joins them from bottom (first pushed) to top (last pushed). So output is '10 -> 20 -> 30 -> null'.

❓ Predict Output

intermediate

What is the output when checking if the stack is empty?

Given a stack initialized with max size 2 and no elements pushed yet, what does the isEmpty() method return?

DSA Typescript

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

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

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

const stack = new Stack(2);
console.log(stack.isEmpty());

A undefined

B false

C true

D Error: isEmpty is not a function

💡 Hint

Check the length of the items array when no elements are pushed.

The stack is empty initially, so items.length is 0. The isEmpty method returns true when length is 0.

❓ Predict Output

advanced

What error occurs when pushing beyond stack capacity?

What happens if we try to push an element into a full stack of max size 2?

DSA Typescript

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

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

  push(element: number): void {
    if (this.items.length >= this.maxSize) {
      throw new Error('Stack overflow');
    }
    this.items.push(element);
  }
}

const stack = new Stack(2);
stack.push(1);
stack.push(2);
stack.push(3);

A SyntaxError: Unexpected token

B Error: Stack overflow

C TypeError: Cannot read property 'push' of undefined

D No output, element pushed successfully

💡 Hint

Check the condition before pushing and what happens if the stack is full.

The push method throws an error when trying to add an element beyond maxSize. So pushing the third element causes 'Stack overflow' error.

❓ Predict Output

advanced

What is the output after popping elements from the stack?

Given a stack with elements [5, 10, 15] (5 at bottom, 15 at top), what is the printed state after popping two elements?

DSA Typescript

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

  constructor(initialItems: number[]) {
    this.items = initialItems;
  }

  pop(): number | undefined {
    return this.items.pop();
  }

  print(): void {
    console.log(this.items.join(' -> ') + ' -> null');
  }
}

const stack = new Stack([5, 10, 15]);
stack.pop();
stack.pop();
stack.print();

A 5 -> null

B 10 -> 15 -> null

C 5 -> 10 -> 15 -> null

D null

💡 Hint

Popping removes elements from the top (end) of the array.

Popping twice removes 15 and then 10, leaving only 5. Printing shows '5 -> null'.

🧠 Conceptual

expert

Which condition correctly checks if the stack is full?

You have a stack implemented with an array and a maxSize property. Which condition correctly returns true when the stack is full?

A this.items.length === this.maxSize

B this.items.length > this.maxSize

C this.items.length < this.maxSize

D this.items.length !== this.maxSize

💡 Hint

Stack is full when number of elements equals max size.

The stack is full when the number of elements equals maxSize, so length === maxSize is true.

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