Insert at Beginning Head Insert 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'

Adata

Bval

Cnode

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong variable name like 'val' or 'data' instead of 'value'.

The constructor parameter is named 'value', so we assign this.value = value.

2fill in blank

medium

Complete the code to insert a new node at the beginning of the linked list.

DSA Javascript

function insertAtHead(head, value) {
  const newNode = new Node(value);
  newNode.next = [1];
  return newNode;
}

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

Anull

BnewNode

Chead

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Setting newNode.next to null or value instead of head.

The new node's next should point to the current head to insert at beginning.

3fill in blank

hard

Fix the error in the code to correctly insert at the beginning of the list.

DSA Javascript

function insertAtHead(head, value) {
  const newNode = new Node(value);
  newNode.next = head;
  head = [1];
  return head;
}

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

Avalue

BnewNode

Cnull

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning head to value or null instead of newNode.

We must update head to point to the newNode after insertion.

4fill in blank

hard

Fill both blanks to complete the function that inserts a new node at the head and returns the updated list.

DSA Javascript

function insertAtHead(head, value) {
  const newNode = new Node([1]);
  newNode.next = [2];
  return newNode;
}

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

Avalue

Bhead

CnewNode

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'newNode' or 'null' incorrectly in either blank.

The new node is created with 'value' and its next points to current 'head'.

5fill in blank

hard

Fill all three blanks to implement a function that inserts a new node at the beginning and prints the list.

DSA Javascript

function insertAtHeadAndPrint(head, value) {
  const newNode = new Node([1]);
  newNode.next = [2];
  head = newNode;
  let current = head;
  let result = '';
  while (current !== null) {
    result += current.value + ' -> ';
    current = [3];
  }
  result += 'null';
  console.log(result);
  return head;
}

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

Avalue

Bhead

Ccurrent.next

DnewNode

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variables for next pointer or traversal.

Create newNode with 'value', link it to 'head', then traverse using 'current.next'.

Practice

1. What does the "Insert at Beginning" operation do in a singly linked list?

easy

A. Deletes the last node of the list

B. Adds a new node at the end of the list

C. Adds a new node at the start of the list

D. Deletes the first node of the list

Solution

1. Step 1: Understand the operation

   Inserting at the beginning means adding a new node before the current first node.

2. Step 2: Effect on the list

   The new node becomes the new head, pushing the old head to second position.

3. Final Answer:

   Adds a new node at the start of the list -> Option C

4. Quick Check:

   Insert at beginning = Add new head [OK]

Hint: Insert at beginning means new head node [OK]

Common Mistakes:

• Confusing insert at beginning with insert at end
• Thinking it deletes nodes
• Assuming it modifies middle nodes

2. Which of the following is the correct syntax to insert a new node at the beginning of a singly linked list in JavaScript?

easy

A. newNode.next = head; head = newNode;

B. head = newNode.next; newNode = head;

C. head.next = newNode; newNode = head;

D. newNode = head.next; head = newNode;

Solution

1. Step 1: Link new node to current head

   Set newNode.next to point to current head node.

2. Step 2: Update head to new node

   Assign head to newNode so it becomes the first node.

3. Final Answer:

   newNode.next = head; head = newNode; -> Option A

4. Quick Check:

   Link new node to head, then update head [OK]

Hint: Set newNode.next = head, then head = newNode [OK]

Common Mistakes:

• Swapping assignments incorrectly
• Not updating head pointer
• Assigning head.next instead of newNode.next

3. What will be the output linked list after executing the following code?

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

let head = new Node(10);
let newNode = new Node(20);
newNode.next = head;
head = newNode;

// Print list
let current = head;
let result = [];
while(current) {
  result.push(current.data);
  current = current.next;
}
console.log(result);

medium

A. [20, 10]

B. [10, 20]

C. [10]

D. [20]

Solution

1. Step 1: Insert newNode at beginning

   newNode (20) points to head (10), then head updated to newNode.

2. Step 2: Traverse list from new head

   Traversal order: 20 -> 10 -> null, so result array is [20, 10].

3. Final Answer:

   [20, 10] -> Option A

4. Quick Check:

   New node at head means list starts with 20 [OK]

Hint: New node points to old head, head updated [OK]

Common Mistakes:

• Reversing order of nodes in output
• Ignoring head update
• Confusing data values

4. Identify the error in the following code snippet that tries to insert a new node at the beginning of a linked list:

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

let head = new Node(5);
let newNode = new Node(15);
head = newNode;
newNode.next = head;

medium

A. The head is not updated to newNode

B. The next pointer of newNode should be null

C. The newNode is not created properly

D. The newNode.next is assigned after head is updated, causing a cycle

Solution

1. Step 1: Analyze assignment order

   head is set to newNode first, then newNode.next is set to head (which is newNode itself).

2. Step 2: Detect cycle creation

   This causes newNode.next to point to itself, creating a cycle and breaking the list.

3. Final Answer:

   The newNode.next is assigned after head is updated, causing a cycle -> Option D

4. Quick Check:

   Assign next before updating head to avoid cycle [OK]

Hint: Assign newNode.next before head update to avoid cycles [OK]

Common Mistakes:

• Assigning head before newNode.next
• Ignoring pointer references
• Assuming newNode.next should be null always

5. Given a linked list with nodes containing values [30, 20, 10] (head is 30), you want to insert nodes with values [40, 50] at the beginning one by one. What will be the final linked list after these insertions?

hard

A. [40, 50, 30, 20, 10]

B. [50, 40, 30, 20, 10]

C. [30, 20, 10, 40, 50]

D. [10, 20, 30, 40, 50]

Solution

1. Step 1: Insert 40 at beginning

   New head becomes 40, list is [40, 30, 20, 10].

2. Step 2: Insert 50 at beginning

   New head becomes 50, list is [50, 40, 30, 20, 10].

3. Final Answer:

   [50, 40, 30, 20, 10] -> Option B

4. Quick Check:

   Each insert adds new head, order reverses insert sequence [OK]

Hint: Last inserted node becomes new head, list grows front [OK]

Common Mistakes:

• Appending instead of prepending
• Reversing insertion order
• Not updating head after each insert