Why Insert at Beginning of Circular Linked List in DSA Javascript?

The Big Idea

What if you could add a new friend to a circle instantly without breaking the flow?

The Scenario

Imagine you have a group of friends sitting in a circle, passing a ball around. Now, you want to add a new friend right at the start of the circle. Doing this by hand means you have to find the last friend and tell them to pass the ball to the new friend instead. This can get confusing and slow as the circle grows.

The Problem

Manually updating the circle means you must find the last friend every time you add someone at the start. This takes time and can cause mistakes, like breaking the circle or losing track of who passes the ball next.

The Solution

Using a circular linked list lets us add a new friend at the beginning quickly by adjusting just a few pointers. The last friend's link is updated automatically to point to the new start, keeping the circle unbroken and easy to manage.

Before vs After

✗ Before

let last = head;
while (last.next !== head) {
  last = last.next;
}
last.next = newNode;
newNode.next = head;
head = newNode;

✓ After

newNode.next = head.next;
head.next = newNode;
[head.data, newNode.data] = [newNode.data, head.data];

What It Enables

This operation makes it easy to keep adding new elements at the start of a circular list without breaking the circle or wasting time.

Real Life Example

Think of a music playlist that loops forever. Adding a new song at the start means it plays next without stopping the loop or rearranging the whole list.

Key Takeaways

Manually inserting at the start of a circle is slow and error-prone.

Circular linked lists let us insert at the beginning by updating just a few links.

This keeps the circle intact and operations fast.

Practice

1. What happens when you insert a new node at the beginning of a circular linked list?

easy

A. The new node becomes the head and points to the old head, maintaining the circular link.

B. The new node is added at the end, breaking the circular link.

C. The new node replaces the last node in the list.

D. The list becomes linear instead of circular.

Solution

1. Step 1: Understand the circular linked list structure

   In a circular linked list, the last node points back to the head node, forming a circle.

2. Step 2: Insert new node at beginning

   The new node is linked to the current head, and the last node's next pointer is updated to this new node, making it the new head.

3. Final Answer:

   The new node becomes the head and points to the old head, maintaining the circular link. -> Option A

4. Quick Check:

   New head points to old head, circle intact [OK]

Hint: New head points to old head; last node points to new head [OK]

Common Mistakes:

• Forgetting to update last node's next pointer
• Breaking the circular link by not linking last node to new head
• Inserting at end instead of beginning

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

easy

A. const newNode = { data: value, next: head }; last.next = newNode; head = newNode;

B. const newNode = { data: value, next: null }; last.next = head; head = newNode;

C. const newNode = { data: value, next: head }; head.next = newNode; head = newNode;

D. const newNode = { data: value, next: null }; newNode.next = head; head = newNode;

Solution

1. Step 1: Create new node with next pointing to current head

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

2. Step 2: Update last node's next to new node and update head

   Since it's circular, last node's next must point to new node, then head is updated to new node.

3. Final Answer:

   const newNode = { data: value, next: head }; last.next = newNode; head = newNode; -> Option A

4. Quick Check:

   New node next = head, last.next = new node, head updated [OK]

Hint: New node next = head; last.next = new node; update head [OK]

Common Mistakes:

• Not updating last.next to new node
• Setting newNode.next to null instead of head
• Updating head before last.next

3. What will be the output of the following code snippet after inserting 10 at the beginning of the circular linked list?

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

let head = new Node(20);
let second = new Node(30);
head.next = second;
second.next = head; // circular link

// Insert 10 at beginning
const newNode = new Node(10);
newNode.next = head;
second.next = newNode;
head = newNode;

// Print list starting from head
let temp = head;
do {
  console.log(temp.data);
  temp = temp.next;
} while(temp !== head);

medium

A. 20 30 10

B. 10 20 30

C. 10 30 20

D. 30 20 10

Solution

1. Step 1: Understand the initial circular list

   Initially, list is 20 -> 30 -> back to 20.

2. Step 2: Insert 10 at beginning and update links

   New node 10 points to 20 (old head), 30 (last node) points to 10, head updated to 10.

3. Step 3: Print order starting from new head

   Traversal prints 10, then 20, then 30, then stops as it loops back to head.

4. Final Answer:

   10 20 30 -> Option B

5. Quick Check:

   New head 10, then 20, then 30 [OK]

Hint: New head data prints first, then follow next pointers [OK]

Common Mistakes:

• Not updating last node's next to new head
• Printing nodes until null instead of circular condition
• Confusing node order after insertion

4. Identify the error in the following code that inserts a node at the beginning of a circular linked list:

function insertAtBeginning(head, value) {
  const newNode = { data: value, next: head };
  let temp = head;
  while(temp.next !== null) {
    temp = temp.next;
  }
  temp.next = newNode;
  head = newNode;
  return head;
}

medium

A. The function should not return head.

B. The newNode's next should be null, not head.

C. The head should not be updated after insertion.

D. The while loop condition should check for temp.next !== head instead of null.

Solution

1. Step 1: Analyze loop condition for circular list

   In a circular linked list, last node's next points to head, not null, so loop should check temp.next !== head.

2. Step 2: Understand impact of wrong condition

   Checking for null causes infinite loop or error because next is never null in circular list.

3. Final Answer:

   The while loop condition should check for temp.next !== head instead of null. -> Option D

4. Quick Check:

   Loop until last node points to head [OK]

Hint: In circular list, last.next points to head, not null [OK]

Common Mistakes:

• Using null check in circular list traversal
• Not updating last node's next pointer correctly
• Forgetting to update head after insertion

5. You have a circular linked list with nodes containing values 5, 15, and 25. You want to insert a new node with value 10 at the beginning. After insertion, what will be the correct order of nodes when traversed starting from the new head, and why is updating the last node's next pointer essential?

hard

A. 5 -> 15 -> 25 -> 10; last.next should point to old head, not new node.

B. 10 -> 5 -> 15 -> 25; updating last.next is optional since newNode.next points to head.

C. 10 -> 5 -> 15 -> 25; updating last.next maintains the circular link to new head.

D. 10 -> 15 -> 25 -> 5; last.next should point to newNode.next.

Solution

1. Step 1: Insert new node at beginning and update pointers

   New node 10 points to old head 5; last node 25 must point to new node 10 to keep circular link.

2. Step 2: Traverse list from new head

   Traversal order is 10 -> 5 -> 15 -> 25, then back to 10.

3. Step 3: Importance of updating last.next

   If last.next is not updated to new head, circular link breaks and traversal fails.

4. Final Answer:

   10 -> 5 -> 15 -> 25; updating last.next maintains the circular link to new head. -> Option C

5. Quick Check:

   Last node points to new head to keep circle [OK]

Hint: Last node must point to new head to keep circle intact [OK]

Common Mistakes:

• Skipping update of last.next pointer
• Assuming newNode.next update is enough
• Incorrect traversal order after insertion