Create a Circular Singly Linked List in DSA Java

Mental Model

A circular singly linked list connects the last node back to the first node, forming a circle with no end.

Analogy: Imagine people sitting around a round table holding hands; the last person holds hands with the first, so the circle never breaks.

head -> 1 -> 2 -> 3 ->
↑                   ↓
←←←←←←←←←←←←←←←←←←←

Dry Run Walkthrough

Input: Create circular singly linked list with values 1, 2, 3 in order

Goal: Build a circular singly linked list where last node points back to head

Step 1: Create first node with value 1; head points here; next points to itself

head -> [1] -> points back to 1 (itself)

Why: First node must point to itself to form a circle with one node

Step 2: Create second node with value 2; link first node's next to second; second's next points to head

head -> 1 -> [2] -> points back to 1 (head)

Why: Link new node after first and maintain circular link back to head

Step 3: Create third node with value 3; link second node's next to third; third's next points to head

head -> 1 -> 2 -> [3] -> points back to 1 (head)

Why: Add new node at end and keep circle intact by pointing last node to head

Result:

head -> 1 -> 2 -> 3 -> points back to 1 (head)

Annotated Code

DSA Java

public class CircularSinglyLinkedList {
    static class Node {
        int data;
        Node next;
        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    Node head = null;

    // Method to create circular singly linked list from array
    public void create(int[] values) {
        if (values.length == 0) return; // no nodes to create

        head = new Node(values[0]);
        head.next = head; // point to itself to form circle
        Node tail = head;

        for (int i = 1; i < values.length; i++) {
            Node newNode = new Node(values[i]);
            tail.next = newNode; // link last node to new node
            newNode.next = head; // new node points back to head
            tail = newNode; // move tail to new node
        }
    }

    // Print circular list starting from head
    public void printList() {
        if (head == null) {
            System.out.println("List is empty");
            return;
        }
        Node curr = head;
        do {
            System.out.print(curr.data + " -> ");
            curr = curr.next;
        } while (curr != head);
        System.out.println("(back to head)");
    }

    public static void main(String[] args) {
        CircularSinglyLinkedList list = new CircularSinglyLinkedList();
        int[] values = {1, 2, 3};
        list.create(values);
        list.printList();
    }
}

head = new Node(values[0]);

create first node and assign as head

head.next = head;

point first node to itself to form initial circle

tail.next = newNode;

link last node to new node

newNode.next = head;

new node points back to head to maintain circle

tail = newNode;

update tail to new last node

do { ... } while (curr != head);

traverse nodes until back to head to print all nodes

Output

1 -> 2 -> 3 -> (back to head)

Complexity Analysis

Time: O(n) because we create and link each of the n nodes once

Space: O(n) because we store n nodes in memory

vs Alternative: Compared to singly linked list without circle, circular list requires extra step to link last node back to head, but traversal can loop indefinitely without null checks

Edge Cases

empty input array

no nodes created, list remains empty

DSA Java

if (values.length == 0) return;

single element array

one node created pointing to itself forming a circle

DSA Java

head.next = head;

When to Use This Pattern

When you see a problem requiring a list where you can cycle through elements repeatedly without end, think of circular singly linked list to avoid null checks at the end.

Common Mistakes

Mistake: Forgetting to link the last node's next pointer back to head, breaking the circle
Fix: Always set last node's next to head after adding new nodes

Mistake: Not handling empty input, causing null pointer errors
Fix: Check if input array is empty before creating nodes

Summary

Creates a linked list where the last node points back to the first node, forming a circle.

Use when you want to cycle through elements repeatedly without stopping at the end.

The key is to keep the last node's next pointer always pointing back to the head node.

Practice

1. What is the main difference between a circular singly linked list and a regular singly linked list?

easy

A. In a circular singly linked list, nodes have two pointers instead of one.

B. In a circular singly linked list, nodes are stored in an array.

C. In a circular singly linked list, the last node points back to the first node.

D. In a circular singly linked list, the first node points to null.

Solution

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

   A regular singly linked list has nodes where each node points to the next node, and the last node points to null.

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

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

3. Final Answer:

   In a circular singly linked list, the last node points back to the first node. -> Option C

4. Quick Check:

   Last node points to first node = B [OK]

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

Common Mistakes:

• Thinking circular means nodes have two pointers
• Confusing circular list with doubly linked list
• Assuming last node points to null

2. Which of the following is the correct way to create a new node in Java for a circular singly linked list?

easy

A. Node newNode = new Node(); newNode.next = newNode;

B. Node newNode = new Node(data); newNode.next = null;

C. Node newNode = new Node(); newNode.data = data; newNode.next = null;

D. Node newNode = new Node(data); newNode.next = newNode;

Solution

1. Step 1: Understand node creation for circular singly linked list

   When creating a single node in a circular singly linked list, its next pointer should point to itself to form a circle.

2. Step 2: Check each option

   Node newNode = new Node(data); newNode.next = newNode; sets newNode.next = newNode, which correctly points the node to itself. Other options set next to null or do not initialize properly.

3. Final Answer:

   Node newNode = new Node(data); newNode.next = newNode; -> Option D

4. Quick Check:

   Node points to itself when alone = A [OK]

Hint: Single node's next points to itself in circular list [OK]

Common Mistakes:

• Setting next to null for single node
• Not initializing next pointer
• Confusing syntax for node creation

3. What will be the output of the following code snippet that creates a circular singly linked list with two nodes and prints their data?

class Node {
  int data;
  Node next;
  Node(int d) { data = d; next = null; }
}

public class Test {
  public static void main(String[] args) {
    Node head = new Node(10);
    Node second = new Node(20);
    head.next = second;
    second.next = head;

    System.out.print(head.data + " -> " + head.next.data + " -> " + head.next.next.data);
  }
}

medium

A. 10 -> 20 -> 10

B. 10 -> 20 -> null

C. 10 -> 20 -> 20

D. Compilation error

Solution

1. Step 1: Trace the node connections

   head.data = 10, head.next = second (data 20), second.next = head (data 10), forming a circle.

2. Step 2: Evaluate the print statement

   head.data = 10, head.next.data = 20, head.next.next.data = second.next.data = head.data = 10.

3. Final Answer:

   10 -> 20 -> 10 -> Option A

4. Quick Check:

   Circle repeats first node data = 10 -> 20 -> 10 [OK]

Hint: Follow next pointers carefully to see the cycle [OK]

Common Mistakes:

• Assuming next.next is null
• Confusing node data values
• Expecting compilation error

4. Identify the error in the following code that tries to insert a new node at the end of a circular singly linked list:

public void insertEnd(Node head, int data) {
  Node newNode = new Node(data);
  if (head == null) {
    head = newNode;
    newNode.next = head;
  } else {
    Node temp = head;
    while (temp.next != null) {
      temp = temp.next;
    }
    temp.next = newNode;
    newNode.next = head;
  }
}

medium

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

B. The newNode.next should be set to null instead of head.

C. The head should be updated to newNode after insertion.

D. The method should return the new head node.

Solution

1. Step 1: Understand circular list traversal

   In a circular singly linked list, the last node's next points to head, not null.

2. Step 2: Analyze the while loop condition

   The loop checks temp.next != null, which never happens in circular list; it should check temp.next != head to find the last node.

3. Final Answer:

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

4. Quick Check:

   Loop must stop at last node pointing to head = A [OK]

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

Common Mistakes:

• Using null to detect end in circular list
• Not updating newNode.next correctly
• Ignoring head update when list is empty

5. You want to create a circular singly linked list from an array of integers {5, 10, 15} by inserting nodes at the end. Which sequence of next pointers correctly represents the final circular list?

hard

A. 15 -> 10 -> 5 -> 15

B. 5 -> 10 -> 15 -> 5

C. 5 -> 10 -> 15 -> null

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

Solution

1. Step 1: Insert nodes at end in given order

   Insert 5 first, then 10 at end, then 15 at end, preserving order: 5, 10, 15.

2. Step 2: Set last node's next to head

   After insertion, last node (15) points back to head (5), making the list circular.

3. Final Answer:

   5 -> 10 -> 15 -> 5 -> Option B

4. Quick Check:

   Order preserved, last points to first = C [OK]

Hint: Insert at end keeps order; last node points to first [OK]

Common Mistakes:

• Assuming last node points to null
• Reversing insertion order
• Mixing node data order