Stack Implementation Using Linked List in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after these stack operations?

Consider a stack implemented using a linked list. The following operations are performed in order:

push(10), push(20), pop(), push(30), push(40), pop()

What is the printed state of the stack after these operations?

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class Stack {
  constructor() {
    this.top = null;
  }

  push(value) {
    const newNode = new Node(value);
    newNode.next = this.top;
    this.top = newNode;
  }

  pop() {
    if (!this.top) return null;
    const poppedValue = this.top.value;
    this.top = this.top.next;
    return poppedValue;
  }

  print() {
    let current = this.top;
    let result = '';
    while (current) {
      result += current.value + ' -> ';
      current = current.next;
    }
    result += 'null';
    console.log(result);
  }
}

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

A 40 -> 30 -> 10 -> null

B 30 -> 10 -> null

C 20 -> 10 -> null

D 10 -> null

💡 Hint

Remember that pop removes the top element from the stack.

The operations push and pop modify the stack as follows:
push(10): stack is 10 -> null
push(20): stack is 20 -> 10 -> null
pop(): removes 20, stack is 10 -> null
push(30): stack is 30 -> 10 -> null
push(40): stack is 40 -> 30 -> 10 -> null
pop(): removes 40, stack is 30 -> 10 -> null
So the final stack is 30 -> 10 -> null.

🧠 Conceptual

intermediate

What is the time complexity of push and pop in a linked list stack?

In a stack implemented using a linked list, what is the time complexity of the push and pop operations?

A Both push and pop are O(n)

B Push is O(n), pop is O(1)

C Both push and pop are O(1)

D Push is O(1), pop is O(n)

💡 Hint

Think about how many nodes you need to traverse for push and pop.

In a linked list stack, push adds a new node at the head and pop removes the head node. Both operations only involve changing a few pointers and do not require traversing the list, so both are O(1).

🔧 Debug

advanced

Identify the error in this pop method

This pop method is part of a linked list stack implementation. What error will it cause when called on an empty stack?

pop() {
const poppedValue = this.top.value;
this.top = this.top.next;
return poppedValue;
}

DSA Javascript

class Stack {
  constructor() {
    this.top = null;
  }

  pop() {
    const poppedValue = this.top.value;
    this.top = this.top.next;
    return poppedValue;
  }
}

A SyntaxError due to missing return statement

B ReferenceError: top is not defined

C Returns undefined without error

D TypeError: Cannot read property 'value' of null

💡 Hint

What happens if this.top is null?

If the stack is empty, this.top is null. Trying to access this.top.value causes a TypeError because null has no properties.

❓ Predict Output

advanced

What is the output of this stack print after mixed operations?

Given the following stack operations, what is the printed stack?

push(5), push(15), push(25), pop(), push(35), pop(), pop(), push(45), print()

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class Stack {
  constructor() {
    this.top = null;
  }

  push(value) {
    const newNode = new Node(value);
    newNode.next = this.top;
    this.top = newNode;
  }

  pop() {
    if (!this.top) return null;
    const poppedValue = this.top.value;
    this.top = this.top.next;
    return poppedValue;
  }

  print() {
    let current = this.top;
    let result = '';
    while (current) {
      result += current.value + ' -> ';
      current = current.next;
    }
    result += 'null';
    console.log(result);
  }
}

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

A 45 -> 5 -> null

B 5 -> null

C 15 -> 5 -> null

D 35 -> 15 -> 5 -> null

💡 Hint

Track each push and pop carefully to see what remains.

Operations step-by-step:
push(5): 5 -> null
push(15): 15 -> 5 -> null
push(25): 25 -> 15 -> 5 -> null
pop(): removes 25, stack is 15 -> 5 -> null
push(35): 35 -> 15 -> 5 -> null
pop(): removes 35, stack is 15 -> 5 -> null
pop(): removes 15, stack is 5 -> null
push(45): 45 -> 5 -> null
Final stack: 45 -> 5 -> null

🧠 Conceptual

expert

Why is a linked list preferred over an array for stack implementation in some cases?

Which of the following is the best reason to choose a linked list over an array for implementing a stack?

A Linked lists allow dynamic memory usage without resizing, while arrays may need resizing.

B Linked lists use less memory than arrays for the same number of elements.

C Arrays provide faster push and pop operations than linked lists.

D Linked lists allow direct access to elements by index, arrays do not.

💡 Hint

Think about memory allocation and resizing.

Linked lists allocate memory dynamically for each element, so they do not require resizing. Arrays have fixed size and may need costly resizing operations when full.

Practice

1. What is the main advantage of implementing a stack using a linked list instead of an array?

easy

A. Dynamic size, no fixed limit on number of elements

B. Faster access to middle elements

C. Uses less memory for small stacks

D. Allows random access to elements

Solution

1. Step 1: Understand stack size limitation in arrays

   Arrays have fixed size or require resizing, which can be costly.

2. Step 2: Linked list dynamic size advantage

   Linked lists grow and shrink dynamically without fixed size limits.

3. Final Answer:

   Dynamic size, no fixed limit on number of elements -> Option A

4. Quick Check:

   Linked list stacks grow dynamically [OK]

Hint: Linked list stacks grow dynamically, arrays don't [OK]

Common Mistakes:

• Thinking linked lists allow random access
• Confusing memory usage benefits
• Assuming arrays are always faster

2. Which of the following is the correct way to create a new node in a linked list stack in JavaScript?

easy

A. const node = Node(val, null);

B. const node = new Node(val, null);

C. const node = { value: val, next: null };

D. const node = { val: value, nextNode: null };

Solution

1. Step 1: Identify correct object property names

   Standard node uses 'value' and 'next' properties.

2. Step 2: Check JavaScript object literal syntax

   const node = { value: val, next: null }; correctly creates an object with 'value' and 'next' keys.

3. Final Answer:

   const node = { value: val, next: null }; -> Option C

4. Quick Check:

   Object with value and next keys [OK]

Hint: Node uses 'value' and 'next' keys in object [OK]

Common Mistakes:

• Using incorrect property names like 'val' or 'nextNode'
• Calling Node as a function without 'new'
• Missing 'const' or wrong syntax

3. What will be the output after pushing 10, then 20, then 30 onto an empty linked list stack and then popping once?

medium

A. Stack is empty

B. Stack top value is 10

C. Stack top value is 30

D. Stack top value is 20

Solution

1. Step 1: Push 10, 20, 30 in order

   Stack after pushes: top -> 30 -> 20 -> 10 -> null

2. Step 2: Pop once removes top (30)

   New top after pop is 20.

3. Final Answer:

   Stack top value is 20 -> Option D

4. Quick Check:

   Pop removes 30, next top is 20 [OK]

Hint: Last pushed is first popped, next top is previous push [OK]

Common Mistakes:

• Thinking pop removes bottom element
• Confusing order of pushes
• Assuming stack becomes empty after one pop

4. Given this pop method code for a linked list stack, what is the error?

pop() {
  if (!this.top) return null;
  const poppedNode = this.top;
  this.top = poppedNode.next;
  return poppedNode.value;
}

medium

A. Should check if poppedNode.next exists before assigning

B. Should decrement stack size counter after pop

C. Should set poppedNode.next to null after popping

D. No error, code works correctly

Solution

1. Step 1: Analyze pop method logic

   Pop removes top node and returns its value correctly.

2. Step 2: Check for missing stack size update

   Stack size counter is not decremented, causing size mismatch.

3. Final Answer:

   Should decrement stack size counter after pop -> Option B

4. Quick Check:

   Pop must update size counter [OK]

Hint: Always update size counter on push/pop [OK]

Common Mistakes:

• Thinking next pointer must be cleared
• Assuming code returns wrong value
• Ignoring size counter updates

5. How would you modify a linked list stack to support a peek() method that returns the top element without removing it? Choose the correct implementation.

hard

A. peek() { return this.top ? this.top.value : null; }

B. peek() { const temp = this.pop(); this.push(temp); return temp; }

C. peek() { return this.top.next ? this.top.next.value : null; }

D. peek() { this.top = this.top.next; return this.top.value; }

Solution

1. Step 1: Understand peek method purpose

   Peek returns top value without changing stack.

2. Step 2: Evaluate each option

   peek() { return this.top ? this.top.value : null; } returns top value safely without modifying stack; others modify or access wrong nodes.

3. Final Answer:

   peek() { return this.top ? this.top.value : null; } -> Option A

4. Quick Check:

   Peek returns top value without removal [OK]

Hint: Peek reads top value, no pop or pointer changes [OK]

Common Mistakes:

• Using pop inside peek causing removal
• Accessing next node instead of top
• Changing top pointer in peek