Pop Using Linked List Node in DSA Javascript

Mental Model

Pop removes the last item from a linked list by finding the second last node and cutting off the last node.

Analogy: Imagine a chain of paper clips linked together. To remove the last clip, you hold the second last clip and unhook the last one.

head -> 1 -> 2 -> 3 -> null

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null, pop last node

Goal: Remove the last node (3) and update the list to end at node 2

Step 1: let prev = null; let curr = this.head (1)

prev=null, head -> [curr->1] -> 2 -> 3 -> null

Why: Initialize pointers: curr starts at head, prev will track second last node

Step 2: while (curr.next): prev = curr (1), curr = curr.next (2)

head -> [prev->1] -> [curr->2] -> 3 -> null

Why: Advance curr, update prev to node before it

Step 3: while (curr.next): prev = curr (2), curr = curr.next (3)

head -> 1 -> [prev->2] -> [curr->3] -> null

Why: Continue traversal until curr is at last node

Step 4: curr.next == null, exit while loop

head -> 1 -> [prev->2] -> [curr->3] -> null

Why: prev now points to second last node, curr to last

Step 5: set prev.next = null

head -> 1 -> 2 -> null

Why: Cut off last node by making second last the new end

Step 6: return curr.value (3)

head -> 1 -> 2 -> null

Why: Return the value of the removed node

Result:

head -> 1 -> 2 -> null

Annotated Code

DSA Javascript

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

class LinkedList {
  constructor() {
    this.head = null;
  }

  append(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let curr = this.head;
    while (curr.next) {
      curr = curr.next;
    }
    curr.next = newNode;
  }

  pop() {
    if (!this.head) return null; // empty list
    if (!this.head.next) {
      const val = this.head.value;
      this.head = null; // single node list
      return val;
    }
    let prev = null;
    let curr = this.head;
    while (curr.next) {
      prev = curr; // keep track of node before last
      curr = curr.next;
    }
    prev.next = null; // remove last node
    return curr.value;
  }

  printList() {
    let curr = this.head;
    let result = '';
    while (curr) {
      result += curr.value + ' -> ';
      curr = curr.next;
    }
    result += 'null';
    console.log(result);
  }
}

// Driver code
const list = new LinkedList();
list.append(1);
list.append(2);
list.append(3);
list.printList();
const poppedValue = list.pop();
console.log('Popped:', poppedValue);
list.printList();

while (curr.next) {

advance curr to last node, keep prev as second last

prev.next = null; // remove last node

cut off last node by setting second last node's next to null

return curr.value;

return value of removed last node

Output

1 -> 2 -> 3 -> null

Popped: 3

1 -> 2 -> null

Complexity Analysis

Time: O(n) because we must traverse the list to find the last node

Space: O(1) because we only use a few pointers regardless of list size

vs Alternative: Compared to arrays where pop is O(1), linked list pop is O(n) because we must find the second last node

Edge Cases

empty list

pop returns null, no changes made

DSA Javascript

if (!this.head) return null; // empty list

single node list

pop removes the only node and sets head to null

DSA Javascript

if (!this.head.next) { const val = this.head.value; this.head = null; return val; }

When to Use This Pattern

When you need to remove the last item from a singly linked list, use the pop pattern by traversing to the second last node and cutting off the last.

Common Mistakes

Mistake: Trying to remove last node without tracking the second last node
Fix: Keep a pointer to the node before the last to update its next pointer to null

Mistake: Not handling empty or single node lists separately
Fix: Add checks for empty list and single node list before traversal

Summary

Removes the last node from a singly linked list by updating the second last node's next pointer to null.

Use when you want to delete the last element from a linked list.

The key is to find the second last node to cut off the last node safely.

Practice

1. What does the pop() operation do in a linked list implemented using nodes?

easy

A. Adds a new node at the end

B. Returns the value of the last node without removing it

C. Removes the first node and returns its value

D. Removes the last node and returns its value

Solution

1. Step 1: Understand pop operation in linked list

   The pop operation removes the last node from the linked list and returns its value.

2. Step 2: Differentiate from other operations

   Adding a node is push, removing first node is shift, and peeking returns value without removal.

3. Final Answer:

   Removes the last node and returns its value -> Option D

4. Quick Check:

   pop() removes last node = B [OK]

Hint: Pop always removes the last node in linked list [OK]

Common Mistakes:

• Confusing pop with push (adding nodes)
• Thinking pop removes the first node
• Assuming pop only returns value without removal

2. Which of the following is the correct syntax to remove the last node in a singly linked list in JavaScript?

easy

A. list.popNode()

B. list.deleteTail()

C. list.pop()

D. list.removeLast()

Solution

1. Step 1: Identify standard method name

   In JavaScript linked list implementations, pop() is the standard method to remove the last node.

2. Step 2: Check other options

   Other method names like popNode(), removeLast(), or deleteTail() are not standard or common.

3. Final Answer:

   list.pop() -> Option C

4. Quick Check:

   pop() removes last node syntax = D [OK]

Hint: Use pop() to remove last node in linked list [OK]

Common Mistakes:

• Using non-standard method names
• Confusing pop() with other removal methods
• Assuming popNode() is built-in

3. Consider the following linked list and pop operation in JavaScript:

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

class LinkedList {
  constructor() {
    this.head = null;
  }
  push(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let current = this.head;
    while (current.next) {
      current = current.next;
    }
    current.next = newNode;
  }
  pop() {
    if (!this.head) return null;
    if (!this.head.next) {
      const val = this.head.value;
      this.head = null;
      return val;
    }
    let current = this.head;
    while (current.next.next) {
      current = current.next;
    }
    const val = current.next.value;
    current.next = null;
    return val;
  }
}

const list = new LinkedList();
list.push(10);
list.push(20);
list.push(30);
const poppedValue = list.pop();
console.log(poppedValue);

What will be printed?

medium

A. 30

B. 20

C. 10

D. null

Solution

1. Step 1: Trace push operations

   Nodes added in order: 10 -> 20 -> 30

2. Step 2: Trace pop operation

   Pop removes last node (30) and returns its value.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Last node value popped = 30 [OK]

Hint: Pop returns last pushed value in linked list [OK]

Common Mistakes:

• Confusing pop with removing first node
• Expecting 20 instead of 30
• Assuming pop returns null if list not empty

4. The following pop() method for a singly linked list has a bug. What is the error?

pop() {
  if (!this.head) return null;
  let current = this.head;
  while (current.next) {
    current = current.next;
  }
  const val = current.value;
  current = null;
  return val;
}

medium

A. It does not update the previous node's next to null

B. It does not handle empty list

C. It returns the wrong node's value

D. It causes infinite loop

Solution

1. Step 1: Analyze traversal to last node

   The code moves current to last node correctly but does not track previous node.

2. Step 2: Check removal logic

   Setting current = null only changes local variable, does not remove last node from list.

3. Step 3: Identify missing update

   Previous node's next should be set to null to remove last node.

4. Final Answer:

   It does not update the previous node's next to null -> Option A

5. Quick Check:

   Missing previous.next = null causes bug = A [OK]

Hint: Update previous node's next to null to remove last node [OK]

Common Mistakes:

• Not tracking previous node during traversal
• Setting current = null does not remove node
• Ignoring empty list check

5. You have a singly linked list with nodes: 5 -> 15 -> 25 -> 35 -> null.
You perform two pop operations in a row. What is the state of the linked list after these operations?

hard

A. 15 -> 25 -> 35 -> null

B. 5 -> 15 -> null

C. 5 -> 15 -> 25 -> null

D. null

Solution

1. Step 1: Initial list nodes

   List is 5 -> 15 -> 25 -> 35 -> null.

2. Step 2: First pop removes last node

   Pop removes 35, list becomes 5 -> 15 -> 25 -> null.

3. Step 3: Second pop removes new last node

   Pop removes 25, list becomes 5 -> 15 -> null.

4. Final Answer:

   5 -> 15 -> null -> Option B

5. Quick Check:

   Two pops remove last two nodes = A [OK]

Hint: Each pop removes last node, so list shrinks from tail [OK]

Common Mistakes:

• Removing nodes from the front instead of end
• Removing only one node after two pops
• Assuming list becomes empty after two pops