Pop Using Linked List Node in DSA Javascript - Build from Scratch

Pop Using Linked List Node

📖 Scenario: You are managing a simple list of tasks using a linked list. Each task is a node connected to the next one. You want to remove the last task from the list when it is done.

🎯 Goal: Build a linked list with three tasks, then remove (pop) the last task node from the list, and finally print the remaining tasks.

📋 What You'll Learn

Create a linked list node class called Node with value and next properties

Create three linked list nodes with values "Task1", "Task2", and "Task3" connected in order

Write a function called popLastNode that removes the last node from the linked list

Print the linked list values after popping the last node in the format: Task1 -> Task2 -> null

💡 Why This Matters

🌍 Real World

Linked lists are used in many applications like task scheduling, undo functionality in editors, and managing playlists where items are dynamically added or removed.

💼 Career

Understanding linked lists and how to manipulate nodes is fundamental for software development roles, especially those involving data structure optimization and memory management.

1

Create Linked List Nodes

Create a class called Node with a constructor that takes value and sets this.value and this.next to null. Then create three nodes called node1, node2, and node3 with values "Task1", "Task2", and "Task3" respectively. Connect node1.next to node2 and node2.next to node3.

DSA Javascript

class Node {
  constructor(value) {
    // Your code here
  }
}

// Create nodes and connect them
// Your code here

Hint

Define the Node class with value and next. Then create three nodes and link them by setting next.

2

Set Head of the Linked List

Create a variable called head and assign it to node1 to represent the start of the linked list.

DSA Javascript

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

const node1 = new Node("Task1");
const node2 = new Node("Task2");
const node3 = new Node("Task3");

node1.next = node2;
node2.next = node3;

// Set the head of the linked list
// Your code here

Hint

Assign head to the first node node1 to mark the start of the list.

3

Write Function to Pop Last Node

Write a function called popLastNode that takes head as input and removes the last node from the linked list. The function should return the updated head. Handle the case when the list has only one node by returning null.

DSA Javascript

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

const node1 = new Node("Task1");
const node2 = new Node("Task2");
const node3 = new Node("Task3");

node1.next = node2;
node2.next = node3;

const head = node1;

// Write popLastNode function below
// Your code here

Hint

Use a loop to find the second last node, then set its next to null to remove the last node.

4

Print Linked List After Pop

Call popLastNode(head) and assign the result back to head. Then write a printList function that prints the linked list values separated by -> and ending with null. Finally, call printList(head) to display the updated list.

DSA Javascript

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

const node1 = new Node("Task1");
const node2 = new Node("Task2");
const node3 = new Node("Task3");

node1.next = node2;
node2.next = node3;

const head = node1;

function popLastNode(head) {
  if (head === null) return null;
  if (head.next === null) return null;
  let current = head;
  while (current.next.next !== null) {
    current = current.next;
  }
  current.next = null;
  return head;
}

// Call popLastNode and print the list
// Your code here

Hint

After popping, print the list by traversing from head and joining values with ->, ending with null.

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