Creating a Singly Linked List from Scratch in DSA Javascript - Debugging & Practice

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of the linked list after these insertions?

Consider a singly linked list where you insert nodes with values 10, 20, and 30 at the end. What will be the printed linked list?

DSA Javascript

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

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

  insertAtEnd(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;
  }

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

const list = new LinkedList();
list.insertAtEnd(10);
list.insertAtEnd(20);
list.insertAtEnd(30);
list.printList();

A null

B 30 -> 20 -> 10 -> null

C 10 -> 20 -> null

D 10 -> 20 -> 30 -> null

💡 Hint

Think about how nodes are added at the end and how the list is printed from head to tail.

Nodes are inserted at the end, so the list grows as 10, then 10->20, then 10->20->30. Printing starts from head and follows next pointers until null.

🧠 Conceptual

intermediate

What happens when you insert a node into an empty singly linked list?

When you insert a node into an empty singly linked list, what is the correct update to the list?

A The new node becomes the head of the list.

B The new node becomes the tail but not the head.

C The list remains empty because head is null.

D The new node points to itself as next.

💡 Hint

Think about what the head pointer should reference when the list is empty.

In an empty list, head is null. Inserting a node means head must point to this new node, making it the first element.

🔧 Debug

advanced

Why does this linked list insertion code cause an infinite loop?

Find the bug causing an infinite loop in this insertion code snippet:

DSA Javascript

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

A The line 'current = current;' does not move to the next node, causing an infinite loop.

B The newNode is not created properly, causing a null reference.

C The head is not updated when the list is empty.

D The while loop condition should be 'current !== null' instead of 'current.next !== null'.

💡 Hint

Check how the pointer moves inside the while loop.

Inside the loop, 'current = current;' does not advance the pointer, so the loop never ends.

❓ Predict Output

advanced

What is the output after deleting the head node from this list?

Given a singly linked list with nodes 5 -> 15 -> 25 -> null, what is the printed list after deleting the head node?

DSA Javascript

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

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

  insertAtEnd(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;
  }

  deleteHead() {
    if (!this.head) return;
    this.head = this.head.next;
  }

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

const list = new LinkedList();
list.insertAtEnd(5);
list.insertAtEnd(15);
list.insertAtEnd(25);
list.deleteHead();
list.printList();

A 5 -> 15 -> 25 -> null

B null

C 15 -> 25 -> null

D 25 -> null

💡 Hint

Deleting the head means the second node becomes the new head.

After deleting the head (5), the head points to 15, so the list is 15 -> 25 -> null.

🧠 Conceptual

expert

How many nodes are in the list after these operations?

Start with an empty singly linked list. Insert 3 nodes with values 1, 2, 3 at the end. Then delete the head node twice. How many nodes remain in the list?

A 3

B 1

C 2

D 0

💡 Hint

Count nodes after each operation carefully.

After inserting 3 nodes, list has 3 nodes. Deleting head twice removes first two nodes, leaving 1 node.

Practice

1. What is the main purpose of a Singly Linked List in data structures?

easy

A. To store elements with random access by index

B. To store elements in a tree-like hierarchy

C. To store elements in a linear order where each element points to the next one

D. To store elements in a fixed-size array

Solution

1. Step 1: Understand the structure of a singly linked list

   A singly linked list stores elements in nodes where each node points to the next node, forming a chain.

2. Step 2: Compare with other data structures

   Unlike arrays or trees, singly linked lists do not support random access or hierarchical storage.

3. Final Answer:

   To store elements in a linear order where each element points to the next one -> Option C

4. Quick Check:

   Singly linked list = linear chain of nodes [OK]

Hint: Remember: singly linked list is a chain of nodes [OK]

Common Mistakes:

• Confusing linked list with arrays
• Thinking linked list supports random access
• Mixing linked list with tree structures

2. Which of the following is the correct way to define a Node class for a singly linked list in JavaScript?

easy

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

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

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

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

Solution

1. Step 1: Identify the correct property assignments for a node

   A node should store the given value and have a pointer to the next node, initially null.

2. Step 2: Check each option's constructor

   class Node { constructor(value) { this.value = value; this.next = null; } } correctly assigns value and sets next to null. Others assign incorrectly or swap properties.

3. Final Answer:

   class Node { constructor(value) { this.value = value; this.next = null; } } -> Option B

4. Quick Check:

   Node stores value and next pointer [OK]

Hint: Node must store value and next=null initially [OK]

Common Mistakes:

• Swapping value and next assignments
• Not initializing next to null
• Leaving value or next undefined

3. What will be the output after running this code?

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

class LinkedList {
  constructor() {
    this.head = null;
  }
  add(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }
  print() {
    let current = this.head;
    let result = '';
    while (current) {
      result += current.value + ' -> ';
      current = current.next;
    }
    result += 'null';
    console.log(result);
  }
}

const list = new LinkedList();
list.add(10);
list.add(20);
list.add(30);
list.print();

medium

A. 10 -> 20 -> 30 -> null

B. 30 -> 20 -> 10 -> null

C. 10 -> 20 -> null

D. null

Solution

1. Step 1: Trace the add method calls

   Adding 10 sets head to node with value 10. Adding 20 and 30 appends nodes at the end.

2. Step 2: Trace the print method

   Print traverses from head: 10, then 20, then 30, then null.

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option A

4. Quick Check:

   Nodes added in order, printed in order [OK]

Hint: Add appends at end; print shows nodes in insertion order [OK]

Common Mistakes:

• Assuming add inserts at head
• Printing nodes in reverse order
• Missing last node in print

4. Identify the error in this linked list add method and select the fix:

add(value) {
  const newNode = new Node(value);
  if (this.head === null) {
    this.head = newNode;
  } else {
    let current = this.head;
    while (current.next !== null) {
      current = current.next;
    }
    current = newNode;
  }
}

medium

A. Replace current = newNode; with current.next = newNode;

B. Replace this.head = newNode; with this.head.next = newNode;

C. Remove the while loop entirely

D. Change if (this.head === null) to if (!this.head.next)

Solution

1. Step 1: Understand the purpose of the while loop

   The loop finds the last node where current.next is null.

2. Step 2: Identify the mistake in assignment

   Assigning current = newNode; only changes the local variable, not the list. It should link the last node's next to newNode.

3. Final Answer:

   Replace current = newNode; with current.next = newNode; -> Option A

4. Quick Check:

   Link last node's next to new node [OK]

Hint: Assign newNode to current.next, not current [OK]

Common Mistakes:

• Assigning newNode to current variable instead of current.next
• Changing head incorrectly
• Removing necessary traversal loop

5. You want to create a method remove(value) in your singly linked list that deletes the first node with the given value. Which approach correctly handles removing the head node and other nodes?

hard

A. Remove node by setting head = null if value matches, else do nothing

B. Always traverse from head and remove node by setting current = current.next without checking head separately

C. Traverse list and remove node by setting current.next = null when value matches

D. Check if head has the value, update head to head.next; else traverse and update previous.next to current.next when found

Solution

1. Step 1: Handle removal of head node

   If the head node contains the value, update head to head.next to remove it.

2. Step 2: Traverse and remove non-head nodes

   Traverse nodes keeping track of previous; when node with value found, set previous.next to current.next to unlink it.

3. Final Answer:

   Check if head has the value, update head to head.next; else traverse and update previous.next to current.next when found -> Option D

4. Quick Check:

   Remove head or unlink node by adjusting pointers [OK]

Hint: Handle head removal separately, then unlink nodes [OK]

Common Mistakes:

• Not updating head when removing first node
• Breaking links incorrectly causing list loss
• Setting current.next = null removes too much