Stack Implementation Using Linked List in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with given value.

DSA Javascript

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

Drag options to blanks, or click blank then click option'

Avalue

Bnext

Cnull

Dthis.value

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'this.next' instead of 'this.value' for the value property.

Assigning null to value instead of the passed parameter.

The constructor assigns the passed value to the node's value property.

2fill in blank

medium

Complete the push method to add a new node on top of the stack.

DSA Javascript

push(value) {
  const newNode = new Node(value);
  newNode.next = [1];
  this.top = newNode;
  this.size++;
}

Drag options to blanks, or click blank then click option'

AnewNode

Bthis.size

Cthis.top

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Setting newNode.next to null loses the existing stack.

Assigning newNode.next to newNode causes a cycle.

The new node's next points to the current top node before updating top.

3fill in blank

hard

Fix the error in the pop method to correctly remove and return the top node's value.

DSA Javascript

pop() {
  if (!this.top) return null;
  const poppedNode = this.top;
  this.top = [1];
  this.size--;
  return poppedNode.value;
}

Drag options to blanks, or click blank then click option'

ApoppedNode.next

BpoppedNode.value

Cnull

Dthis.top.next

Attempts:

3 left

💡 Hint

Common Mistakes

Setting top to null removes the entire stack.

Returning poppedNode instead of poppedNode.value.

After popping, top should point to the next node of the popped node.

4fill in blank

hard

Fill both blanks to implement the peek method that returns the top value without removing it.

DSA Javascript

peek() {
  if ([1]) {
    return [2];
  }
  return null;
}

Drag options to blanks, or click blank then click option'

Athis.top === null

Bthis.top !== null

Cthis.top.value

Dthis.top

Attempts:

3 left

💡 Hint

Common Mistakes

Checking if top is null instead of not null.

Returning the node instead of its value.

Peek returns the value of the top node if it exists.

5fill in blank

hard

Fill all three blanks to implement the isEmpty method that returns true if stack is empty.

DSA Javascript

isEmpty() {
  return this.size [1] 0;
}

// Usage example:
const stack = new Stack();
console.log(stack.isEmpty()); // [2]
stack.push(10);
console.log(stack.isEmpty()); // [3]

Drag options to blanks, or click blank then click option'

A===

Btrue

Cfalse

D!==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!=' instead of '===' causing wrong boolean.

Swapping true and false in usage examples.

isEmpty returns true if size equals zero, false otherwise.

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