Pop Operation on Stack in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after popping an element from the stack?

Consider the following JavaScript code that implements a stack using an array. What will be the printed state of the stack after the pop operation?

DSA Javascript

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

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

A 10 -> 20 -> null

B 10 -> 20 -> 30 -> null

C 20 -> 30 -> null

D null

💡 Hint

Remember that pop removes the last element added to the stack.

The stack initially has 10, 20, 30. After pop(), 30 is removed. The remaining stack is 10 -> 20 -> null.

❓ Predict Output

intermediate

What error occurs when popping from an empty stack?

What will happen if we try to pop an element from an empty stack implemented as below?

DSA Javascript

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

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

A null

B Error: Stack is empty

C undefined

D TypeError

💡 Hint

What does JavaScript's array pop() return when the array is empty?

JavaScript's pop() returns undefined when called on an empty array, so no error is thrown.

🔧 Debug

advanced

Identify the bug in this pop method implementation

The following pop method is intended to remove and return the top element of the stack. What is the bug that will cause incorrect behavior?

DSA Javascript

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

A Returning null instead of undefined causes error

B Using shift() removes the bottom element, not the top

C No bug, code works correctly

D Missing check for undefined before pop

💡 Hint

Think about which end of the array represents the top of the stack.

shift() removes the first element, but stack pop should remove the last element (top). Using shift() removes the bottom element.

❓ Predict Output

advanced

What is the stack state after multiple pop operations?

Given the following code, what will be printed after the two pop operations?

DSA Javascript

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

const stack = new Stack();
stack.push(5);
stack.push(15);
stack.push(25);
stack.pop();
stack.pop();
stack.print();

A 5 -> null

B 15 -> 25 -> null

C null

D 5 -> 15 -> null

💡 Hint

Each pop removes the last pushed element.

After pushing 5, 15, 25, popping twice removes 25 and 15, leaving only 5.

🧠 Conceptual

expert

Why is pop operation on stack O(1) time complexity?

Choose the best explanation for why the pop operation on a stack implemented with an array is O(1) time complexity.

A Because pop searches the entire array to find the last element

B Because pop copies all elements to a new array except the last

C Because pop removes the first element causing all others to shift

D Because pop removes the last element directly without shifting other elements

💡 Hint

Think about what happens internally when pop is called on an array.

Pop removes the last element directly without moving other elements, so it takes constant time.

Practice

1. What does the pop() operation do in a stack?

easy

A. Removes and returns the top element of the stack

B. Adds a new element to the bottom of the stack

C. Returns the bottom element without removing it

D. Clears all elements from the stack

Solution

1. Step 1: Understand stack behavior

   A stack follows Last In First Out (LIFO) principle, so the last added element is on top.

2. Step 2: Define pop operation

   The pop operation removes and returns the top element of the stack, following LIFO.

3. Final Answer:

   Removes and returns the top element of the stack -> Option A

4. Quick Check:

   pop() = remove top element [OK]

Hint: Pop always removes the last added item [OK]

Common Mistakes:

• Thinking pop adds elements
• Confusing pop with peek (which only returns)
• Assuming pop removes bottom element

2. Which of the following is the correct syntax to pop an element from a stack implemented as an array in JavaScript?

easy

A. pop(stack);

B. stack.popElement();

C. stack.pop();

D. stack.remove();

Solution

1. Step 1: Recall JavaScript array pop method

   JavaScript arrays have a built-in method pop() to remove the last element.

2. Step 2: Match correct syntax

   The correct syntax to pop from an array named stack is stack.pop();

3. Final Answer:

   stack.pop(); -> Option C

4. Quick Check:

   Use array.pop() to remove last element [OK]

Hint: Use array.pop() to remove top stack element [OK]

Common Mistakes:

• Using non-existent methods like popElement()
• Calling pop as a standalone function
• Using remove() which is not valid for arrays

3. What will be the output of the following code?

const stack = [10, 20, 30];
const popped = stack.pop();
console.log(popped);
console.log(stack);

medium

A. 20
[10, 20, 30]

B. undefined
[10, 20]

C. 30
[10, 20, 30]

D. 30
[10, 20]

Solution

1. Step 1: Understand pop() effect on array

   pop() removes the last element (30) and returns it, so popped is 30.

2. Step 2: Check stack after pop

   After pop, stack becomes [10, 20] because 30 is removed.

3. Final Answer:

   30 [10, 20] -> Option D

4. Quick Check:

   pop() returns last element and removes it [OK]

Hint: pop() returns last item and removes it from array [OK]

Common Mistakes:

• Expecting pop() to return second last element
• Assuming stack remains unchanged after pop
• Confusing pop() return value with stack content

4. Identify the error in the following code snippet that tries to pop an element from a stack:

let stack = [1, 2, 3];
let popped = stack.pop;
console.log(popped);

medium

A. pop is not a function

B. pop method is not called, missing parentheses

C. stack is not defined

D. pop returns undefined always

Solution

1. Step 1: Check how pop is used

   The code assigns stack.pop without parentheses, so it assigns the function itself, not the result.

2. Step 2: Correct usage of pop

   To pop and get the value, pop must be called with parentheses: stack.pop().

3. Final Answer:

   pop method is not called, missing parentheses -> Option B

4. Quick Check:

   Use stack.pop() to call pop method [OK]

Hint: Always use parentheses to call pop() method [OK]

Common Mistakes:

• Forgetting parentheses when calling pop
• Thinking pop is a property, not a function
• Assuming pop returns undefined without call

5. Given a stack implemented as an array stack = [5, 10, 15], what will be the state of the stack after performing two consecutive pop() operations?

hard

A. [5]

B. [10]

C. [5, 10]

D. []

Solution

1. Step 1: Perform first pop()

   First pop removes 15, stack becomes [5, 10].

2. Step 2: Perform second pop()

   Second pop removes 10, stack becomes [5].

3. Final Answer:

   [5] -> Option A

4. Quick Check:

   Two pops remove last two elements [OK]

Hint: Each pop removes one top element [OK]

Common Mistakes:

• Removing elements from the bottom instead of top
• Assuming pop does not change stack
• Confusing number of pops with elements removed