Search⌘ K
AI Features
Home
Courses
Learn Data Structures and Algorithms

Circular Linked Lists Operations

Explore how to perform key operations on circular linked lists in Python. Understand traversal methods, insertion at different positions, and deletion techniques while ensuring the circular connection is preserved. Gain insights into time and space complexities, and learn to handle edge cases such as single-node loops for effective problem-solving.

We'll cover the following...

At this stage, the difference between a circular linked list and a standard singly linked list is established. Instead of the last node pointing to NULL, it points back to the head node, forming a loop. As a result, the list has no natural termination point, and traversal requires explicit stopping conditions.

Now, let’s focus on the operations that can be performed on circular linked lists. While many of these operations are conceptually similar to those used in singly linked lists, there is an important difference: the circular connection must always be preserved.

Because the list forms a loop, operations such as traversal, insertion, and deletion must be implemented carefully. In particular:

  • Traversal cannot rely on reaching NULL to stop.

  • Insertions must ensure that the circular link remains intact.

  • Deletions must reconnect neighboring nodes so that the loop structure is maintained.

Traversal in a circular linked list

Traversal in a circular linked list is slightly different from traversal in a standard singly linked list. In a regular linked list, traversal stops when the current node becomes NULL. In a circular linked list, this stopping condition does not exist because the last node points back to the head.

Instead, traversal must stop when it returns to the starting node. Typically, the traversal steps are:

  1. Start traversal from the head node.

  2. Print the value stored in the current node.

  3. Move to the next node using current.next.

  4. Stop the traversal when the pointer reaches the head node again.

Let's look at the following interactive visualizer for circular linked list traversal.

Python implementation of traversal in a circular linked list

The following code creates a simple circular linked list and traverses it once, stopping when the traversal returns to the head node.

Python 3.14.0
class ListNode:
    def __init__(self, data):
        self.data = data
        self.next = None   # Points to the next node
class CircularLinkedList:
    def __init__(self):
        self.head = None   # Points to the first node
    def traverse(self):
        if self.head is None:
            print("The list is empty.")
            return
        current = self.head   # Start from the head node
        while True:
            print(current.data, end=" -> ")   # Process current node
            current = current.next            # Move to the next node
            if current == self.head:          # Stop when traversal returns to head
                break
        print(current.data, "(back to head)")
# Create a circular linked list manually: 10 -> 20 -> 30 -> back to 10
sample_list = CircularLinkedList()
first = ListNode(10)
second = ListNode(20)
third = ListNode(30)
sample_list.head = first
first.next = second
second.next = third
third.next = first   # Make the list circular
# Traverse the circular linked list
print("Traversal of circular linked list:", end=" ")
sample_list.traverse()
Doubly linked list traversal

  • Time complexity: O(n)O(n) because each node is visited once.

  • Space complexity: O(1)O(1) as traversal only uses a single pointer variable.

Insertion in a circular linked list

Insertion in a circular linked list is similar to the insertion in a singly linked list, but there is one extra requirement: the circular connection must remain intact. ...