Bird
Raised Fist0
DSA Pythonprogramming

Create a Circular Singly Linked List in DSA Python

Choose your learning style10 modes available
LearnWhyDeepVisualTryChallengeProjectRecallTime
Mental Model
A circular singly linked list is like a chain where the last link connects back to the first, forming a circle.
Analogy: Imagine a round table where each person holds hands with the next, and the last person holds hands with the first, so the circle never breaks.
head -> 1 -> 2 -> 3 ->
ā†‘                   ā†“
ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†
Dry Run Walkthrough
Input: Create circular 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 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 to extend the list
Step 3: Create node with value 3 and link it after node 2
head -> 1 -> 2 -> [3] -> null
Why: Add third node after second to extend the list
Step 4: Link last node (3) back to head (1) to form circle
head -> 1 -> 2 -> 3 ->
ā†‘                   ā†“
ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†
Why: Close the list into a circle so traversal can loop
Result: 
head -> 1 -> 2 -> 3 ->
ā†‘                   ā†“
ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†ā†
Annotated Code
DSA Python
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class CircularSinglyLinkedList:
    def __init__(self):
        self.head = None

    def create(self, values):
        if not values:
            return
        self.head = Node(values[0])  # create head node
        curr = self.head
        for val in values[1:]:
            curr.next = Node(val)  # link new node after current
            curr = curr.next      # move current to new node
        curr.next = self.head      # link last node back to head

    def print_list(self):
        if not self.head:
            print("List is empty")
            return
        curr = self.head
        result = []
        while True:
            result.append(str(curr.data))
            curr = curr.next
            if curr == self.head:
                break
        print(" -> ".join(result) + " -> (back to head)")

# Driver code
cll = CircularSinglyLinkedList()
cll.create([1, 2, 3])
cll.print_list()
self.head = Node(values[0]) # create head node
initialize head with first value
curr.next = Node(val) # link new node after current
attach new node to current node's next
curr = curr.next # move current to new node
advance current pointer to newly added node
curr.next = self.head # link last node back to head
close the list into a circle by linking last node to head
while True: result.append(str(curr.data)) curr = curr.next if curr == self.head: break
traverse nodes until we loop back to head
OutputSuccess
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 arrays, circular linked lists allow easy looping without index resets but require pointer management
Edge Cases
empty input list
no nodes created, list remains empty
DSA Python
if not values:
    return
single element list
head points to single node which points to itself
DSA Python
curr.next = self.head      # link last node back to head
When to Use This Pattern
When you need a list that loops back to start for continuous cycling, use a circular singly linked list to avoid resetting pointers manually.
Common Mistakes
Mistake: Forgetting to link the last node back to the head, leaving the list linear
Fix: Add the line that sets last node's next pointer to head after all nodes are created
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/5)
1. What is a key characteristic of a circular singly linked list compared to a regular singly linked list?
easy
A. It uses an array internally instead of nodes.
B. The last node points back to the first node, forming a circle.
C. Each node has two pointers, one to the next and one to the previous node.
D. The list has a fixed size and cannot grow.

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 list types

    Unlike doubly linked lists, nodes have only one pointer. Unlike arrays, nodes are linked dynamically. The circular nature is unique to this structure where the last node points back to the first node, forming a circle.

  3. Final Answer:

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

  4. Quick Check:

    Circular list loops back = C [OK]
Hint: Remember: circular means last node links to first [OK]
Common Mistakes:
  • Confusing circular with doubly linked list
  • Thinking nodes have two pointers
  • Assuming fixed size like arrays
2. Which of the following is the correct way to initialize an empty circular singly linked list in Python?
easy
A. head = None
B. head = Node(0); head.next = None
C. head = Node(0); head.next = head
D. head = []

Solution

  1. Step 1: Understand empty list initialization

    An empty circular singly linked list has no nodes, so head should be None.

  2. Step 2: Analyze other options

    head = Node(0); head.next = None sets next to None, which is not circular. head = Node(0); head.next = head creates a node pointing to itself, which is a single-node circular list, not empty. head = [] uses a list, not a linked list.

  3. Final Answer:

    head = None -> Option A

  4. Quick Check:

    Empty list head = None [OK]
Hint: Empty list means head points to nothing (None) [OK]
Common Mistakes:
  • Setting head.next to None in empty list
  • Creating a node when list is empty
  • Using Python list [] instead of nodes
3. What will be the output of the following code snippet? 
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

head = Node(1)
second = Node(2)
third = Node(3)

head.next = second
second.next = third
third.next = head

current = head
result = []
for _ in range(4):
    result.append(current.data)
    current = current.next
print(result)
medium
A. [1, 2, 3, 3]
B. [1, 2, 3, None]
C. [1, 2, 3, 1]
D. RuntimeError due to infinite loop

Solution

  1. Step 1: Understand the circular link setup

    Nodes 1, 2, 3 are linked in a circle: 1->2->3->1.

  2. Step 2: Trace the loop for 4 iterations

    Starting at head (1), the loop collects data: 1, then moves to 2, then 3, then back to 1.

  3. Final Answer:

    [1, 2, 3, 1] -> Option C

  4. Quick Check:

    Loop of 3 nodes repeated once = [1,2,3,1] [OK]
Hint: Follow next pointers carefully for given loop count [OK]
Common Mistakes:
  • Assuming last node points to None
  • Stopping after 3 elements instead of 4
  • Confusing data values with node references
4. Identify the error in the following code that tries to create a circular singly linked list with one node: 
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

head = Node(10)
head.next = None  # Intended to point to head for circular list
medium
A. Data value 10 is invalid for circular lists
B. Node class is missing a previous pointer
C. head should be initialized as None
D. head.next should point to head, not None

Solution

  1. Step 1: Check the pointer assignment for circularity

    For a circular singly linked list with one node, the node's next must point to itself (head), not None.

  2. Step 2: Analyze the given code

    The code sets head.next = None, breaking the circular link.

  3. Final Answer:

    head.next should point to head, not None -> Option D

  4. Quick Check:

    Single node circular list loops to itself [OK]
Hint: Single node circular list next points to itself [OK]
Common Mistakes:
  • Setting next to None instead of head
  • Confusing singly with doubly linked list
  • Thinking data value affects circularity
5. You want to insert a new node with value 4 at the end of an existing circular singly linked list with nodes 1 -> 2 -> 3 -> back to 1. Which of the following code snippets correctly performs this insertion?
hard
A. new_node = Node(4) current = head while current.next != head: current = current.next current.next = new_node new_node.next = head
B. new_node = Node(4) new_node.next = head head.next = new_node
C. new_node = Node(4) head.next = new_node new_node.next = None
D. new_node = Node(4) current = head while current.next != None: current = current.next current.next = new_node new_node.next = head

Solution

  1. Step 1: Locate the last node in the circular list

    Traverse nodes until current.next points back to head, identifying the last node.

  2. Step 2: Insert new node after last node and link it back to head

    Set last node's next to new_node, then new_node's next to head to maintain circularity.

  3. Final Answer:

    Traverse until current.next != head, then set current.next = new_node and new_node.next = head -> Option A

  4. Quick Check:

    Traverse till last node, link new node, maintain circle [OK]
Hint: Find last node by checking next != head, then insert [OK]
Common Mistakes:
  • Setting new_node.next to None breaking circularity
  • Not traversing to last node correctly
  • Assuming head.next is always last node
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard