Create a Circular Singly Linked List in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a node class for the circular singly linked list.

DSA Python

class Node:
    def __init__(self, data):
        self.data = data
        self.[1] = None

Drag options to blanks, or click blank then click option'

Alink

Bprev

Cnext

Dpointer

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' which is for doubly linked lists.

Using 'pointer' or 'link' which are not standard attribute names.

The 'next' attribute points to the next node in the circular singly linked list.

2fill in blank

medium

Complete the code to initialize the circular singly linked list with a head node.

DSA Python

class CircularSinglyLinkedList:
    def __init__(self):
        self.head = [1]

Drag options to blanks, or click blank then click option'

ANode(0)

BNone

C0

Dself

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing head with a Node when the list is empty.

Using 0 or self which are incorrect.

The head is initially None because the list is empty.

3fill in blank

hard

Fix the error in the insert method to correctly insert the first node in the circular singly linked list.

DSA Python

def insert(self, data):
    new_node = Node(data)
    if self.head is None:
        self.head = new_node
        new_node.[1] = new_node
    else:
        # code to insert when list is not empty
        pass

Drag options to blanks, or click blank then click option'

Anext

Bprev

Clink

Dpointer

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' which is not used in singly linked lists.

Not linking the node to itself causing a broken circle.

For a single node in a circular singly linked list, its next points to itself.

4fill in blank

hard

Fill both blanks to complete the code that inserts a new node at the end of the circular singly linked list.

DSA Python

def insert(self, data):
    new_node = Node(data)
    if self.head is None:
        self.head = new_node
        new_node.next = new_node
    else:
        temp = self.head
        while temp.[1] != self.head:
            temp = temp.[2]
        temp.next = new_node
        new_node.next = self.head

Drag options to blanks, or click blank then click option'

Anext

Bprev

Clink

Dpointer

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' which does not exist in singly linked lists.

Using different attributes for traversal causing errors.

To traverse the circular list, use the 'next' attribute to move to the next node.

5fill in blank

hard

Fill all three blanks to complete the method that prints all nodes in the circular singly linked list.

DSA Python

def print_list(self):
    if self.head is None:
        print('List is empty')
        return
    temp = self.head
    while True:
        print(temp.[1], end=' -> ')
        temp = temp.[2]
        if temp == [3]:
            break
    print('None')

Drag options to blanks, or click blank then click option'

Adata

Bnext

Cself.head

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Printing the node object instead of its data.

Using 'head' instead of 'self.head' causing NameError.

Not stopping the loop causing infinite print.

Print the data of each node, move to the next node, and stop when back at the head.

Practice

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