Creating a Singly Linked List from Scratch in DSA Javascript - Code Step by Step

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a Node class with a constructor that sets the value and next pointer.

DSA Javascript

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

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

A0

Bundefined

Cnull

Dthis

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined instead of null for next pointer.

The next pointer should be initialized to null because the new node does not point to any other node yet.

2fill in blank

medium

Complete the code to initialize the head of the linked list to null in the constructor.

DSA Javascript

class LinkedList {
  constructor() {
    this.head = [1];
  }
}

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

Aundefined

Bthis

C0

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Setting head to undefined or 0 instead of null.

The head should be initialized to null to indicate the list is empty at the start.

3fill in blank

hard

Fix the error in the add method to correctly add a new node at the end of the list.

DSA Javascript

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

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

A!==

B===

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using === instead of !== causes infinite loop or no iteration.

The loop should continue while current.next is not null to reach the last node.

4fill in blank

hard

Fill both blanks to complete the printList method that prints all node values.

DSA Javascript

printList() {
  let current = this.head;
  while (current [1] null) {
    console.log(current.[2]);
    current = current.next;
  }
}

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

A!==

Bvalue

C===

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using === instead of !== in loop condition.

Printing current.next instead of current.value.

The loop continues while current is not null, and we print the value of the current node.

5fill in blank

hard

Fill all three blanks to complete the remove method that deletes the first node with the given value.

DSA Javascript

remove(value) {
  if (this.head === null) return;
  if (this.head.[1] === value) {
    this.head = this.head.[2];
    return;
  }
  let current = this.head;
  while (current.next !== null && current.next.[3] !== value) {
    current = current.next;
  }
  if (current.next !== null) {
    current.next = current.next.next;
  }
}

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

Avalue

Bnext

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect property names like head instead of next.

Not updating head when the first node matches.

We check the value of the head node, then update head to head.next if it matches. Then we traverse to find the node before the one to remove by checking current.next.value.

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