Insert at Beginning of Circular Linked List in DSA Javascript - Build from Scratch

Insert at Beginning of Circular Linked List

📖 Scenario: You are managing a circular linked list that represents a playlist of songs. Each node contains the song's name. You want to add a new song at the beginning of the playlist so it plays next.

🎯 Goal: Build a circular linked list and write code to insert a new node at the beginning. Then print the playlist to verify the new song is first and the list remains circular.

📋 What You'll Learn

Create a Node class with data and next properties

Create a CircularLinkedList class with a head property

Add a method insertAtBeginning(data) to insert a new node at the start

Add a method printList() to print the circular list nodes in order

Insert a new song at the beginning and print the updated list

💡 Why This Matters

🌍 Real World

Circular linked lists are used in applications like music playlists, round-robin scheduling, and buffering where the list loops continuously.

💼 Career

Understanding circular linked lists helps in roles involving system design, embedded systems, and performance-critical applications where efficient looping data structures are needed.

1

Create Node and CircularLinkedList classes

Create a class called Node with a constructor that takes data and sets this.data = data and this.next = null. Then create a class called CircularLinkedList with a constructor that sets this.head = null.

DSA Javascript

class Node {
  constructor(data) {
    // Your code here
  }
}

class CircularLinkedList {
  constructor() {
    // Your code here
  }
}

Hint

Remember to set this.data and this.next inside the Node constructor. For CircularLinkedList, initialize head to null.

2

Add insertAtBeginning method

Inside the CircularLinkedList class, add a method called insertAtBeginning(data). This method should create a new Node with the given data. If head is null, set head to the new node and point newNode.next to head. Otherwise, find the last node, set its next to the new node, set newNode.next to head, and update head to newNode.

DSA Javascript

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

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

  insertAtBeginning(data) {
    // Your code here
  }
}

Hint

Check if the list is empty first. If not, find the last node by looping until temp.next === this.head. Then update pointers to insert the new node at the start.

3

Add printList method

Inside the CircularLinkedList class, add a method called printList(). This method should print the data of each node starting from head and moving to next nodes until it loops back to head. Print the data values separated by -> and end with null.

DSA Javascript

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

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

  insertAtBeginning(data) {
    const newNode = new Node(data);
    if (this.head === null) {
      this.head = newNode;
      newNode.next = this.head;
    } else {
      let temp = this.head;
      while (temp.next !== this.head) {
        temp = temp.next;
      }
      temp.next = newNode;
      newNode.next = this.head;
      this.head = newNode;
    }
  }

  printList() {
    // Your code here
  }
}

Hint

Use a do-while loop to traverse the circular list starting from head. Append each node's data to a string and print it after the loop.

4

Insert new song and print playlist

Create an instance of CircularLinkedList called playlist. Insert these songs at the beginning in this order: 'Song3', 'Song2', 'Song1'. Then call playlist.printList() to display the playlist.

DSA Javascript

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

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

  insertAtBeginning(data) {
    const newNode = new Node(data);
    if (this.head === null) {
      this.head = newNode;
      newNode.next = this.head;
    } else {
      let temp = this.head;
      while (temp.next !== this.head) {
        temp = temp.next;
      }
      temp.next = newNode;
      newNode.next = this.head;
      this.head = newNode;
    }
  }

  printList() {
    if (this.head === null) {
      console.log('null');
      return;
    }
    let result = '';
    let temp = this.head;
    do {
      result += temp.data + ' -> ';
      temp = temp.next;
    } while (temp !== this.head);
    result += 'null';
    console.log(result);
  }
}

// Your code here

Hint

Insert songs in reverse order so that 'Song1' becomes the first node. Then print the list to see the order.

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