Create a Circular Singly Linked List in DSA C#

Mental Model

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

Analogy: Imagine a round table where each person holds hands with the next person, and 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 list where last node points back to head

Step 1: Create node with value 1 and set head to it

head -> [1] -> null

Why: Start the list with the first node

Step 2: Create node with value 2 and link it after node 1

head -> 1 -> [2] -> null

Why: Add second node after first

Step 3: Create node with value 3 and link it after node 2

head -> 1 -> 2 -> [3] -> null

Why: Add third node after second

Step 4: Link last node (3) back to head (1) to form circle

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

Why: Close the list into a circle by connecting last to first

Result:

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

Annotated Code

DSA C#

using System;

public class Node
{
    public int data;
    public Node next;

    public Node(int value)
    {
        data = value;
        next = null;
    }
}

public class CircularSinglyLinkedList
{
    public Node head;

    public void Create(int[] values)
    {
        if (values.Length == 0) return;

        head = new Node(values[0]);
        Node current = head;

        for (int i = 1; i < values.Length; i++)
        {
            current.next = new Node(values[i]);
            current = current.next; // advance current to new node
        }

        current.next = head; // link last node back to head to form circle
    }

    public void PrintList(int count)
    {
        Node current = head;
        for (int i = 0; i < count; i++)
        {
            Console.Write(current.data);
            if (i < count - 1) Console.Write(" -> ");
            current = current.next; // advance to next node
        }
        Console.WriteLine(" -> ... (circular)");
    }
}

public class Program
{
    public static void Main()
    {
        CircularSinglyLinkedList list = new CircularSinglyLinkedList();
        int[] values = {1, 2, 3};
        list.Create(values);
        list.PrintList(6); // print 6 nodes to show circularity
    }
}

head = new Node(values[0]);

initialize head with first value

current.next = new Node(values[i]);

link new node after current

current = current.next; // advance current to new node

move current pointer forward to last node

current.next = head; // link last node back to head to form circle

close the list into a circle

current = current.next; // advance to next node

move through nodes for printing

Output

1 -> 2 -> 3 -> 1 -> 2 -> 3 -> ... (circular)

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 a singly linked list with null end, circular list adds one extra link to close the circle with no extra traversal cost

Edge Cases

empty input array

list remains empty with head null

DSA C#

if (values.Length == 0) return;

single element array

node points to itself forming a single-node circle

DSA C#

current.next = head; // link last node back to head to form circle

When to Use This Pattern

When you need a list that loops back to start for repeated cycling, use a circular singly linked list to avoid null ends and enable continuous traversal.

Common Mistakes

Mistake: Forgetting to link the last node back to head, leaving the list linear
Fix: Add current.next = head after all nodes are created to close the circle

Summary

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

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

The key is linking the last node's next pointer back to the head node.

Practice

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

easy

A. The last node points to null in a circular singly linked list.

B. Nodes have two pointers in a circular singly linked list.

C. The last node points back to the first node in a circular singly linked list.

D. Nodes are stored in an array in a circular singly linked list.

Solution

1. Step 1: Understand the node connection in a regular singly linked list

   In a regular singly linked list, the last node's next pointer is null, marking the end.

2. Step 2: Understand the node connection in a circular singly linked list

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

3. Final Answer:

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

4. Quick Check:

   Last node next = first node in circular list [OK]

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

Common Mistakes:

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

2. Which of the following is the correct way to initialize a circular singly linked list with one node in C#?

easy

A. Node head = new Node(5); head.next = head;

B. Node head = new Node(5); head.next = null;

C. Node head = null; head.next = head;

D. Node head = new Node(5); head = null;

Solution

1. Step 1: Create a new node with value 5

   Node head = new Node(5); creates a node with data 5.

2. Step 2: Point the node's next to itself to form a circular link

   head.next = head; makes the list circular with one node.

3. Final Answer:

   Node head = new Node(5); head.next = head; -> Option A

4. Quick Check:

   Single node next points to itself [OK]

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

Common Mistakes:

• Setting next to null instead of self
• Assigning null to head after creation
• Trying to set next on a null head

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 them once?

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

Node head = new Node(1);
Node second = new Node(2);
Node third = new Node(3);
head.next = second;
second.next = third;
third.next = head; // circular link

Node temp = head;
do {
  Console.Write(temp.data + " -> ");
  temp = temp.next;
} while (temp != head);
Console.WriteLine("null");

medium

A. 1 -> 2 -> null

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

C. 1 -> 2 -> 3 -> 3 -> null

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

Solution

1. Step 1: Create nodes and link them circularly

   Nodes 1, 2, 3 are linked so that third.next points back to head, forming a circle.

2. Step 2: Traverse and print nodes once using do-while loop

   The loop prints data starting at head and stops when temp returns to head, printing 1, 2, 3 once.

3. Final Answer:

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

4. Quick Check:

   Loop prints each node once before stopping [OK]

Hint: do-while stops after one full circle [OK]

Common Mistakes:

• Using while loop without do causes skipping first node
• Printing nodes infinitely without stop condition
• Confusing circular list with linear list output

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

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

medium

A. newNode.next should be null, not head.

B. The while loop condition should check for temp.next != head, not null.

C. temp should be initialized to null before the loop.

D. The newNode should be created after the loop.

Solution

1. Step 1: Understand circular list's last node pointer

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

2. Step 2: Correct the loop condition to find last node

   The loop should check temp.next != head to stop at the last node, not temp.next != null.

3. Final Answer:

   The while loop condition should check for temp.next != head, not null. -> Option B

4. Quick Check:

   Last node next = head, not null [OK]

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

Common Mistakes:

• Using null check in circular list traversal
• Setting newNode.next to null breaking circularity
• Initializing temp incorrectly

5. You want to create a circular singly linked list from an array of integers [10, 20, 30, 40]. Which approach correctly creates the circular list and returns the head node?

public Node CreateCircularList(int[] arr) {
  if (arr.Length == 0) return null;
  Node head = new Node(arr[0]);
  Node current = head;
  for (int i = 1; i < arr.Length; i++) {
    current.next = new Node(arr[i]);
    current = current.next;
  }
  // What should be here?
}

hard

A. current.next = head; return head;

B. current.next = null; return head;

C. head.next = current; return current;

D. return current;

Solution

1. Step 1: Create nodes from array and link linearly

   Loop creates nodes for each array element and links them in order.

2. Step 2: Make the list circular by linking last node to head

   Setting current.next = head closes the loop, making the list circular.

3. Step 3: Return the head node

   Return head to provide access to the circular list.

4. Final Answer:

   current.next = head; return head; -> Option A

5. Quick Check:

   Last node points to head to form circle [OK]

Hint: Close circle by linking last node to head [OK]

Common Mistakes:

• Leaving last node next as null
• Returning last node instead of head
• Linking head.next to last node instead of last.next to head