Create a Circular Singly Linked List in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Circular Singly Linked List after Insertions

What is the printed output of the circular singly linked list after inserting nodes with values 10, 20, and 30 in that order?

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

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

    def insert(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = new_node
        else:
            temp = self.head
            while temp.next != self.head:
                temp = temp.next
            temp.next = new_node
            new_node.next = self.head

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

cll = CircularSinglyLinkedList()
cll.insert(10)
cll.insert(20)
cll.insert(30)
cll.print_list()

A 10 -> 20 -> 30 -> (head)

B 10 -> 20 -> 30 -> None

C 30 -> 20 -> 10 -> (head)

D List is empty

💡 Hint

Remember that in a circular singly linked list, the last node points back to the head.

Nodes are inserted at the end, and the last node points back to the head, so the print shows 10 -> 20 -> 30 -> (head).

❓ Predict Output

intermediate

Result of Deleting Head Node in Circular Singly Linked List

What is the printed output after deleting the head node from the circular singly linked list containing 5 -> 15 -> 25 -> (head)?

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

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

    def insert(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = new_node
        else:
            temp = self.head
            while temp.next != self.head:
                temp = temp.next
            temp.next = new_node
            new_node.next = self.head

    def delete_head(self):
        if not self.head:
            return
        if self.head.next == self.head:
            self.head = None
            return
        temp = self.head
        while temp.next != self.head:
            temp = temp.next
        temp.next = self.head.next
        self.head = self.head.next

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

cll = CircularSinglyLinkedList()
cll.insert(5)
cll.insert(15)
cll.insert(25)
cll.delete_head()
cll.print_list()

A 5 -> 15 -> 25 -> (head)

B 15 -> 25 -> (head)

C 25 -> 15 -> (head)

D List is empty

💡 Hint

Deleting the head means the second node becomes the new head.

After deleting the head (5), the list starts from 15 and continues to 25, then back to 15.

🔧 Debug

advanced

Identify the Bug in Circular Singly Linked List Insertion

What is the bug in the following insert method of a circular singly linked list?

DSA Python

def insert(self, data):
    new_node = Node(data)
    if not self.head:
        self.head = new_node
        new_node.next = None
    else:
        temp = self.head
        while temp.next != self.head:
            temp = temp.next
        temp.next = new_node
        new_node.next = self.head

A new_node.next should point to self.head, but it is set to None when list is empty

B The while loop condition should be temp.next == self.head instead of != self.head

C The head should be updated to new_node after insertion

D The method does not create a new node before insertion

💡 Hint

Check what happens when the list is empty and a new node is inserted.

When the list is empty, new_node.next should point to itself to maintain circularity, but it is set to None, breaking the circle.

❓ Predict Output

advanced

Output after Traversing Circular Singly Linked List with One Node

What is the output of the print_list method when the circular singly linked list has only one node with value 42?

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

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

    def insert(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = new_node
        else:
            temp = self.head
            while temp.next != self.head:
                temp = temp.next
            temp.next = new_node
            new_node.next = self.head

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

cll = CircularSinglyLinkedList()
cll.insert(42)
cll.print_list()

A 42

B 42 -> None

C List is empty

D 42 -> (head)

💡 Hint

A single node points to itself in a circular singly linked list.

The single node points back to itself, so the print shows 42 -> (head).

🧠 Conceptual

expert

Why Use Circular Singly Linked List Instead of Singly Linked List?

Which of the following is the main advantage of using a circular singly linked list over a regular singly linked list?

A It automatically sorts the elements during insertion

B It uses less memory than a singly linked list

C It allows traversal from any node back to the head without null checks

D It prevents duplicate values in the list

💡 Hint

Think about how the last node connects in a circular singly linked list.

In a circular singly linked list, the last node points back to the head, enabling continuous traversal without null checks.