Create a Circular Singly Linked List in DSA Javascript - Execution Trace

Concept Flow - Create a Circular Singly Linked List

Create new node

↓

Is list empty?

No→Traverse to last node

↓

Set last.next = new node

↓

Set head = new node

↓

Set new node.next = head

↓

Done

Create a new node, if list is empty set head to it and point next to itself. Otherwise, find last node, link it to new node, and new node points back to head.

Execution Sample

DSA Javascript

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

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

  add(value) {
    const newNode = new Node(value);
    if (this.head === null) {
      this.head = newNode;
      newNode.next = this.head;
      return;
    }
    let last = this.head;
    while (last.next !== this.head) {
      last = last.next;
    }
    last.next = newNode;
    newNode.next = this.head;
  }
}

// Usage example:
// const list = new CircularLinkedList();
// list.add(10);
// list.add(20);
// list.add(30);
// Results in: head -> 10 -> 20 -> 30 -> head

This code creates nodes and links them to form a circular singly linked list.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Create node with value 10	None	None	null
2	List empty? Yes	None	head = node10	head -> 10 -> ?
3	Set node10.next = head	10	node10.next = head	head -> 10 -> head
4	Create node with value 20	10	None	head -> 10 -> head
5	List empty? No	10	Traverse to last node (node10)	head -> 10 -> head
6	Set last.next = node20	10	node10.next = node20	head -> 10 -> 20 -> ?
7	Set node20.next = head	10, 20	node20.next = head	head -> 10 -> 20 -> head
8	Create node with value 30	10, 20	None	head -> 10 -> 20 -> head
9	List empty? No	10, 20	Traverse to last node (node20)	head -> 10 -> 20 -> head
10	Set last.next = node30	10, 20	node20.next = node30	head -> 10 -> 20 -> 30 -> ?
11	Set node30.next = head	10, 20, 30	node30.next = head	head -> 10 -> 20 -> 30 -> head
12	End	10, 20, 30	No changes	head -> 10 -> 20 -> 30 -> head

💡 All nodes added, last node points back to head to complete circular list

Variable Tracker

Variable	Start	After Step 2	After Step 6	After Step 10	Final
head	null	node10	node10	node10	node10
node10.next	null	head	node20	node20	node20
node20.next	null	null	null	node30	node30
node30.next	null	null	null	null	head

Key Moments - 3 Insights

Why do we set the new node's next pointer to head?

Setting new node's next to head keeps the list circular, as shown in steps 3, 7, and 11 in the execution table.

How do we find the last node to link the new node?

We traverse nodes starting from head until we find a node whose next points back to head, as in steps 5 and 9.

What happens if the list is empty when adding the first node?

We set head to the new node and point its next to itself, making a single-node circular list, as in steps 2 and 3.

Visual Quiz - 3 Questions

Look at the execution table, what does node20.next point to after step 11?

A node10

B node30

C head

D null

💡 Hint

Check the Pointer Changes and Visual State columns at step 11.

At which step does the list first become circular?

A Step 2

B Step 3

C Step 6

D Step 7

💡 Hint

Look for when the first node's next points back to head in the execution table.

If we skip setting node30.next to head at step 11, what happens?

A node30.next points to null, breaking circularity

B List remains circular

C node20.next points to head

D head becomes null

💡 Hint

Refer to the importance of node.next pointing to head in key moments and execution table step 11.

Concept Snapshot

Create node with value
If list empty: head = node, node.next = head
Else: find last node (next points to head)
Set last.next = new node
Set new node.next = head
List is circular: last node points back to head

Full Transcript

To create a circular singly linked list, start by creating a new node. If the list is empty, set the head to this new node and point its next to itself, making a single-node circular list. If the list is not empty, traverse from head to find the last node whose next points back to head. Then set this last node's next to the new node, and set the new node's next to head. This keeps the list circular. Repeat these steps to add more nodes. The execution table shows each step, pointer changes, and the visual state of the list. Key moments clarify why the new node's next points to head and how traversal finds the last node.

Practice

1. What is a key characteristic of a circular singly linked list compared to a regular singly linked list?

easy

A. The last node points back to the first node, forming a circle.

B. Each node has two pointers, one to the next and one to the previous node.

C. It stores data in a sorted order automatically.

D. It uses an array internally to store nodes.

Solution

1. Step 1: Understand the structure of a circular singly linked list

   In a circular singly linked list, the last node's next pointer points back to the first node, creating a loop.

2. Step 2: Compare with other linked lists

   Unlike doubly linked lists, circular singly linked lists have only one pointer per node and form a circle, not a linear chain.

3. Final Answer:

   The last node points back to the first node, forming a circle. -> Option A

4. Quick Check:

   Last node's next = first node [OK]

Hint: Remember: circular means last node links to first [OK]

Common Mistakes:

• Confusing circular singly linked list with doubly linked list
• Thinking nodes have two pointers
• Assuming data is sorted automatically

2. Which of the following is the correct way to initialize an empty circular singly linked list in JavaScript?

easy

A. const head = { data: null, next: head };

B. const head = null; // no nodes yet

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

D. const head = []; // empty array

Solution

1. Step 1: Understand empty list initialization

   An empty circular singly linked list has no nodes, so the head pointer is null.

2. Step 2: Check other options

   const head = { data: null, next: null }; creates a node with null data and next pointer, which is not empty. const head = { data: null, next: head }; references head before assignment, causing error. const head = []; // empty array uses an array, not a linked list.

3. Final Answer:

   const head = null; // no nodes yet -> Option B

4. Quick Check:

   Empty list head = null [OK]

Hint: Empty list means head is null, no nodes created [OK]

Common Mistakes:

• Creating a node with null data instead of null head
• Referencing head before declaration
• Using arrays instead of linked list nodes

3. What will be the output of the following code snippet that creates a circular singly linked list with nodes 1, 2, 3 and prints the list once?

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

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

  append(data) {
    const newNode = new Node(data);
    if (!this.head) {
      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;
    }
  }

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

const list = new CircularSinglyLinkedList();
list.append(1);
list.append(2);
list.append(3);
console.log(list.printList());

medium

A. null

B. 1 -> 2 -> 3 -> 1 -> 2 -> 3 -> null

C. 1 -> 2 -> 3

D. 1 -> 2 -> 3 -> null

Solution

1. Step 1: Understand append method behavior

   Each new node is added at the end, and its next points to head, maintaining circularity.

2. Step 2: Trace printList method

   printList starts at head and loops until it reaches head again, appending data with ' -> '. Finally adds 'null'. So output is '1 -> 2 -> 3 -> null'.

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option D

4. Quick Check:

   Print once around circle = 1 -> 2 -> 3 -> null [OK]

Hint: Print loops until back to head once, then stops [OK]

Common Mistakes:

• Printing infinite loop by not stopping at head
• Missing 'null' at end
• Printing nodes multiple times

4. Identify the bug in this code snippet that tries to append a node to a circular singly linked list:

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

medium

A. newNode.next should point to this.head when list is empty, not null.

B. The while loop condition should be temp.next === this.head.

C. The head should be set to newNode every time a node is appended.

D. The newNode should not be created inside the append method.

Solution

1. Step 1: Check initialization for empty list

   When list is empty, newNode.next must point to head itself to maintain circularity, not null.

2. Step 2: Verify loop and pointer updates

   The while loop and pointer updates are correct; only the initial next pointer is wrong.

3. Final Answer:

   newNode.next should point to this.head when list is empty, not null. -> Option A

4. Quick Check:

   Empty list node next = head, not null [OK]

Hint: Empty list node next must loop to itself [OK]

Common Mistakes:

• Setting newNode.next to null breaks circular link
• Wrong while loop condition
• Resetting head incorrectly

5. You want to insert a new node with value 4 after the node with value 3 in a circular singly linked list. Given the list: 3 -> 1 -> 2 -> (back to 3), which code snippet correctly performs this insertion?

hard

A. let temp = head;
while (temp.next !== head) {
temp = temp.next;
}
const newNode = new Node(4);
temp.next = newNode;
newNode.next = head;

B. const newNode = new Node(4);
newNode.next = head;
head.next = newNode;

C. let temp = head;
while (temp.data !== 3) {
temp = temp.next;
}
const newNode = new Node(4);
newNode.next = temp.next;
temp.next = newNode;

D. head = new Node(4);
head.next = oldHead;

Solution

1. Step 1: Locate node with value 3

   Traverse from head until temp.data equals 3 to find the correct insertion point.

2. Step 2: Insert new node after node 3

   Create newNode with data 4, set newNode.next to temp.next, then set temp.next to newNode to insert correctly.

3. Final Answer:

   Traverse from head until finding node with value 3, then insert new node after it. -> Option C

4. Quick Check:

   Insert after node 3 by adjusting pointers [OK]

Hint: Find node 3, insert new node by pointer swap [OK]

Common Mistakes:

• Inserting at wrong position
• Not updating pointers correctly
• Replacing head incorrectly