Insert at Beginning Head Insert in DSA Javascript - Build from Scratch

Insert at Beginning Head Insert

📖 Scenario: Imagine you are managing a simple list of tasks to do. You want to add new tasks at the very start of your list so that the newest tasks get done first.

🎯 Goal: You will build a singly linked list and learn how to insert a new node at the beginning (head) of the list.

📋 What You'll Learn

Create a Node class with value and next properties

Create a LinkedList class with a head property

Write a method insertAtBeginning(value) to add a new node at the start

Write a method printList() to display the list values in order

💡 Why This Matters

🌍 Real World

Linked lists are used in many programs where you need a flexible list that can grow or shrink easily, like task managers or undo features.

💼 Career

Understanding linked lists is fundamental for software development jobs, especially when working with low-level data structures or preparing for coding interviews.

1

Create Node and LinkedList classes

Create a class called Node with a constructor that takes value and sets this.value and this.next to null. Then create a class called LinkedList with a constructor that sets this.head to null.

DSA Javascript

// Your code here

Hint

Think of Node as a box holding a value and a pointer to the next box. LinkedList starts empty with head as null.

2

Add insertAtBeginning method

Inside the LinkedList class, add a method called insertAtBeginning(value). This method should create a new Node with the given value, set its next to the current head, and then update head to this new node.

DSA Javascript

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

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

  // Your code here
}

Hint

Remember to link the new node to the old head before updating the head pointer.

3

Add printList method

Inside the LinkedList class, add a method called printList(). This method should start from head and traverse the list, collecting each node's value into an array. Then join the array values with ' -> ' and add ' -> null' at the end. Finally, print the resulting string.

DSA Javascript

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

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

  insertAtBeginning(value) {
    const newNode = new Node(value);
    newNode.next = this.head;
    this.head = newNode;
  }

  // Your code here
}

Hint

Use a loop to visit each node and collect values, then print them joined with arrows.

4

Insert nodes and print the list

Create a new LinkedList object called list. Use insertAtBeginning to add these values in order: 10, 20, 30. Then call list.printList() to display the list.

DSA Javascript

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

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

  insertAtBeginning(value) {
    const newNode = new Node(value);
    newNode.next = this.head;
    this.head = newNode;
  }

  printList() {
    let current = this.head;
    const values = [];
    while (current !== null) {
      values.push(current.value);
      current = current.next;
    }
    console.log(values.join(' -> ') + ' -> null');
  }
}

// Your code here

Hint

Remember that inserting at the beginning means the last inserted value appears first when printing.

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