Why Circular Linked List and Real World Use Cases in DSA Python - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a circular linked list where the last node points back to the head.

DSA Python

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

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

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = [1]
        else:
            temp = self.head
            while temp.next != self.head:
                temp = temp.next
            temp.next = new_node
            new_node.next = self.head

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

Aself.head

BNone

Cnew_node

Dtemp

Attempts:

3 left

💡 Hint

Common Mistakes

Setting the last node's next to None breaks the circular structure.

Pointing the last node's next to itself creates a single-node loop only.

In a circular linked list, the last node's next pointer must point back to the head node to form a circle.

2fill in blank

medium

Complete the code to traverse and print all nodes in a circular linked list exactly once.

DSA Python

def print_list(cll):
    if not cll.head:
        return
    temp = cll.head
    while True:
        print(temp.data, end=' -> ')
        temp = [1]
        if temp == cll.head:
            break
    print('null')

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

Atemp

Bcll.head

Ctemp.prev

Dtemp.next

Attempts:

3 left

💡 Hint

Common Mistakes

Using temp instead of temp.next causes an infinite loop.

Using temp.prev is invalid for singly linked lists.

To move through the circular linked list, we update temp to temp.next at each step.

3fill in blank

hard

Fix the error in the code to correctly insert a new node after the head in a circular linked list.

DSA Python

def insert_after_head(cll, data):
    if not cll.head:
        cll.head = Node(data)
        cll.head.next = cll.head
    else:
        new_node = Node(data)
        new_node.next = cll.head.next
        cll.head.next = [1]

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

Acll.head

Bdata

Cnew_node

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning head.next to data instead of the new node.

Assigning head.next to None breaks the list.

To insert after the head, the head's next pointer must point to the new node.

4fill in blank

hard

Fill both blanks to create a function that checks if a circular linked list contains a given value.

DSA Python

def contains(cll, value):
    if not cll.head:
        return False
    temp = cll.head
    while True:
        if temp.data == [1]:
            return [2]
        temp = temp.next
        if temp == cll.head:
            break
    return False

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

Avalue

BTrue

CFalse

Dcll.head

Attempts:

3 left

💡 Hint

Common Mistakes

Returning False when the value is found.

Comparing with cll.head instead of the value.

We compare each node's data with the value and return True if found.

5fill in blank

hard

Fill all three blanks to create a dictionary that maps each node's data to its next node's data in a circular linked list.

DSA Python

def map_to_next(cll):
    if not cll.head:
        return {}
    result = {}
    temp = cll.head
    while True:
        result[[1]] = [2]
        temp = [3]
        if temp == cll.head:
            break
    return result

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

Atemp.data

Btemp.next.data

Ctemp

Dtemp.next

Attempts:

3 left

💡 Hint

Common Mistakes

Using temp.next as key or value instead of temp.next.data.

Not updating temp inside the loop causing infinite loop.

The dictionary maps each node's data (key) to the next node's data (value). We use temp to iterate.

Practice

1. What is the main advantage of using a circular linked list over a singly linked list?

easy

A. It allows traversal from any node back to itself without stopping

B. It uses less memory than a singly linked list

C. It automatically sorts the elements

D. It prevents duplicate elements

Solution

1. Step 1: Understand the structure of a circular linked list

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

2. Step 2: Compare traversal behavior

   This connection allows traversal starting from any node and continuing indefinitely without a null end.

3. Final Answer:

   It allows traversal from any node back to itself without stopping -> Option A

4. Quick Check:

   Circular linked list traversal loops back [OK]

Hint: Circular lists loop back to start, unlike linear lists [OK]

Common Mistakes:

• Thinking circular lists save memory
• Assuming circular lists sort data automatically
• Confusing circular with doubly linked lists

2. Which of the following is the correct way to check if a circular linked list has only one node in Python?

easy

A. if head.next == None:

B. if head.next.next == head:

C. if head.next == head:

D. if head == None:

Solution

1. Step 1: Recall circular linked list node connections

   In a circular linked list with one node, the node's next points to itself.

2. Step 2: Identify the correct condition

   Checking if head.next == head confirms only one node exists.

3. Final Answer:

   if head.next == head: -> Option C

4. Quick Check:

   One node points to itself [OK]

Hint: One node's next points to itself in circular list [OK]

Common Mistakes:

• Checking for None in circular lists
• Confusing two-node condition with one-node
• Using head.next.next without verifying head.next

3. What will be the output of the following code snippet that uses a circular linked list?

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  # circular link

current = head
count = 0
while count < 5:
    print(current.data, end=' ')
    current = current.next
    count += 1

medium

A. 1 2 3 None None

B. 1 2 3 4 5

C. 1 2 3 3 3

D. 1 2 3 1 2

Solution

1. Step 1: Understand the circular link setup

   The last node points back to the head, so traversal cycles through 1 -> 2 -> 3 -> 1 -> 2 ...

2. Step 2: Trace the loop for 5 prints

   Prints: 1, 2, 3, then loops back to 1, then 2 again.

3. Final Answer:

   1 2 3 1 2 -> Option D

4. Quick Check:

   Loop cycles through nodes repeatedly [OK]

Hint: Circular list repeats nodes after last one [OK]

Common Mistakes:

• Expecting new values beyond 3
• Assuming None appears in circular list
• Confusing count limit with node count

4. Identify the error in the following code that tries to insert a new node after the head in a circular linked list:

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

head = Node(10)
head.next = head

new_node = Node(20)
new_node.next = head.next
head.next = new_node

# Expected list: 10 -> 20 -> 10 (circular)

medium

A. The new_node.next should point to head, not head.next

B. No error; code correctly inserts new_node after head

C. head.next should be updated after new_node.next assignment

D. head.next should be None initially, not head

Solution

1. Step 1: Analyze the initial circular list setup

   head.next points to head, so list has one node pointing to itself.

2. Step 2: Check insertion steps

   new_node.next = head.next sets new_node.next to head, then head.next = new_node inserts new_node after head.

3. Final Answer:

   No error; code correctly inserts new_node after head -> Option B

4. Quick Check:

   Insertion maintains circular link correctly [OK]

Hint: Check pointer updates order carefully in circular lists [OK]

Common Mistakes:

• Thinking new_node.next should point to head directly
• Assuming head.next must be None initially
• Confusing insertion order causing broken links

5. Which real-world scenario best fits the use of a circular linked list?

hard

A. Managing a playlist that repeats songs continuously

B. Storing user data in a database table

C. Implementing a stack for undo operations

D. Sorting numbers in ascending order

Solution

1. Step 1: Understand circular linked list behavior

   Circular linked lists allow continuous looping through elements without stopping.

2. Step 2: Match behavior to real-world use case

   A playlist that repeats songs continuously needs to cycle through songs endlessly, matching circular list behavior.

3. Final Answer:

   Managing a playlist that repeats songs continuously -> Option A

4. Quick Check:

   Continuous looping fits circular list use [OK]

Hint: Continuous cycles match circular list use cases [OK]

Common Mistakes:

• Choosing database storage which is unrelated
• Confusing stack behavior with circular list
• Assuming sorting needs circular lists