Delete Node at Beginning in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to delete the first node of the linked list.

DSA Javascript

function deleteAtBeginning(head) {
  if (head === null) return null;
  return [1];
}

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

Ahead.next

Bhead

Chead.prev

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Returning head instead of head.next

Returning null without checking

Trying to access head.prev in singly linked list

To delete the first node, we return the second node which is head.next.

2fill in blank

medium

Complete the code to update the head pointer after deleting the first node.

DSA Javascript

function deleteAtBeginning(head) {
  if (head === null) return null;
  let newHead = [1];
  return newHead;
}

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

Ahead.prev

Bhead.next

Chead

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using head.prev which does not exist in singly linked list

Assigning newHead to head itself

Assigning newHead to null without checking

The new head after deletion is the next node of the current head.

3fill in blank

hard

Fix the error in the code to correctly delete the first node and return the updated list.

DSA Javascript

function deleteAtBeginning(head) {
  if (head === null) return null;
  head = [1];
  return head;
}

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

Ahead.prev

Bhead

Cnull

Dhead.next

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning head to itself causing no deletion

Assigning head to null causing empty list

Using head.prev which is undefined

Assigning head to head.next removes the first node from the list.

4fill in blank

hard

Fill both blanks to delete the first node and update the head correctly.

DSA Javascript

function deleteAtBeginning(head) {
  if (head === null) return null;
  let temp = [1];
  head = [2];
  return head;
}

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

Ahead

Bhead.next

Cnull

Dhead.prev

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping the order of assignments

Using head.prev which does not exist

Assigning temp to head.next instead of head

We store the current head in temp, then update head to head.next to delete the first node.

5fill in blank

hard

Fill all three blanks to delete the first node and return the updated list safely.

DSA Javascript

function deleteAtBeginning(head) {
  if (head === null) return null;
  let temp = [1];
  head = [2];
  temp = [3];
  return head;
}

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

Ahead

Bhead.next

Cnull

Dhead.prev

Attempts:

3 left

💡 Hint

Common Mistakes

Not clearing temp after deletion

Using head.prev which is undefined

Assigning temp to head.next instead of null

We save the current head in temp, update head to head.next, then clear temp to null to help garbage collection.

Practice

1. What happens to the head pointer when you delete the first node in a singly linked list?

easy

A. It moves to the next node in the list

B. It becomes null immediately

C. It points to the last node

D. It remains unchanged

Solution

1. Step 1: Understand the head pointer role

   The head pointer points to the first node in the list.

2. Step 2: Effect of deleting the first node

   Deleting the first node means the head must now point to the second node, which becomes the new first node.

3. Final Answer:

   It moves to the next node in the list -> Option A

4. Quick Check:

   Head points to next node after deletion [OK]

Hint: Head always moves to next node when deleting first [OK]

Common Mistakes:

• Assuming head becomes null even if list has more nodes
• Thinking head points to last node after deletion
• Not updating head pointer at all

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

easy

A. delete head;

B. head.next = head;

C. head = head.next;

D. head = null.next;

Solution

1. Step 1: Understand how to move head pointer

   To delete the first node, assign head to head.next to skip the first node.

2. Step 2: Check each option

   head = head.next; correctly assigns head to head.next. head.next = head; reverses pointers incorrectly. delete head; deletes the variable but not the node. head = null.next; is invalid syntax.

3. Final Answer:

   head = head.next; -> Option C

4. Quick Check:

   Assign head to head.next to delete first node [OK]

Hint: Use head = head.next to remove first node [OK]

Common Mistakes:

• Using delete keyword incorrectly
• Assigning head.next to head instead of head to head.next
• Using invalid syntax like null.next

3. Consider the following linked list code in JavaScript:

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

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

// Delete first node
head = head.next;

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

What will be printed?

medium

A. []

B. [10, 20, 30]

C. [30]

D. [20, 30]

Solution

1. Step 1: Initial linked list nodes

   The list has nodes with data 10 -> 20 -> 30.

2. Step 2: Deleting first node by head = head.next

   Head moves from node 10 to node 20, so node 10 is removed.

3. Step 3: Printing remaining nodes

   Starting from new head (20), the list is 20 -> 30, so result array is [20, 30].

4. Final Answer:

   [20, 30] -> Option D

5. Quick Check:

   After deletion, list starts at 20 [OK]

Hint: Deleting first node skips first data in output [OK]

Common Mistakes:

• Printing original list without deletion
• Confusing head.next with head
• Forgetting to update head pointer

4. The following code attempts to delete the first node of a linked list but causes an error:

head.next = head.next.next;

What is the problem with this code if head points to the first node?

medium

A. It deletes the second node instead of the first node

B. It causes a runtime error if head.next is null

C. It correctly deletes the first node

D. It sets head to null incorrectly

Solution

1. Step 1: Analyze what head.next = head.next.next does

   This changes the next pointer of the first node to skip the second node, effectively deleting the second node.

2. Step 2: Check if first node is deleted

   The head pointer still points to the first node, so the first node is not deleted.

3. Final Answer:

   It deletes the second node instead of the first node -> Option A

4. Quick Check:

   head.next changes second node, not head itself [OK]

Hint: Changing head.next skips second node, not first [OK]

Common Mistakes:

• Thinking this deletes the first node
• Ignoring possible null pointer if list has one node
• Confusing head and head.next pointers

5. You have a singly linked list with nodes: 5 -> 10 -> 15 -> 20. Write a function in JavaScript to delete the first node and return the new head. What will be the list after deletion?

hard

A. 20

B. 10 -> 15 -> 20

C. 15 -> 20

D. 5 -> 10 -> 15 -> 20

Solution

1. Step 1: Write function to delete first node

   Function returns head.next to skip first node:
   function deleteFirstNode(head) { return head ? head.next : null; }

2. Step 2: Apply function to list 5 -> 10 -> 15 -> 20

   New head points to node with data 10, so list becomes 10 -> 15 -> 20.

3. Final Answer:

   10 -> 15 -> 20 -> Option B

4. Quick Check:

   Deleting first node moves head to second node [OK]

Hint: Return head.next to delete first node [OK]

Common Mistakes:

• Returning head instead of head.next
• Not handling empty list (null head)
• Deleting wrong node by changing next pointers incorrectly