Insert at End of Circular Linked List in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after inserting a node at the end of a circular linked list

What is the printed state of the circular linked list after inserting a new node with value 4 at the end?

DSA Python

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

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

    def insert_end(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = new_node
            return
        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 = CircularLinkedList()
cll.insert_end(1)
cll.insert_end(2)
cll.insert_end(3)
cll.insert_end(4)
cll.print_list()

A 1 -> 2 -> 3 -> 4

B 1 -> 2 -> 3 -> (head)

C 1 -> 2 -> 3 -> 4 -> (head)

D 4 -> 1 -> 2 -> 3 -> (head)

💡 Hint

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

After inserting 4 at the end, the list contains nodes 1, 2, 3, and 4 in order, and the last node points back to the head node 1. The print_list method shows this sequence ending with '-> (head)'.

❓ Predict Output

intermediate

Output after inserting into an empty circular linked list

What is the printed state of the circular linked list after inserting a single node with value 10 into an empty list?

DSA Python

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

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

    def insert_end(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = new_node
            return
        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 = CircularLinkedList()
cll.insert_end(10)
cll.print_list()

A 10 -> (head)

B List is empty

C 10 -> 10 -> (head)

D None

💡 Hint

When the list is empty, the new node points to itself.

Inserting into an empty circular linked list creates a single node that points to itself. The print shows the single node value followed by '-> (head)'.

🔧 Debug

advanced

Identify the error in circular linked list insertion code

What error will this code produce when inserting a node at the end of a circular linked list?

DSA Python

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

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

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

cll = CircularLinkedList()
cll.insert_end(5)
cll.insert_end(6)
cll.insert_end(7)

A AttributeError

B SyntaxError

C No error, runs correctly

D Infinite loop

💡 Hint

Check the condition in the while loop that finds the last node.

The while loop condition 'temp.next != None' never becomes false in a circular linked list because the last node points back to head, not None. This causes an infinite loop.

❓ Predict Output

advanced

Output after multiple insertions at the end of circular linked list

What is the printed state of the circular linked list after inserting nodes with values 10, 20, 30, 40 in that order at the end?

DSA Python

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

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

    def insert_end(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            new_node.next = new_node
            return
        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 = CircularLinkedList()
for val in [10, 20, 30, 40]:
    cll.insert_end(val)
cll.print_list()

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

B 40 -> 30 -> 20 -> 10 -> (head)

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

D List is empty

💡 Hint

Nodes are inserted at the end, so order is preserved.

Nodes are inserted at the end, so the list contains 10, 20, 30, 40 in order, and the last node points back to the head.

🧠 Conceptual

expert

Why is the last node's next pointer important in a circular linked list?

In a circular linked list, what is the main reason the last node's next pointer points back to the head node?

A To prevent insertion of new nodes at the end

B To allow traversal to continue indefinitely in a loop

C To store the size of the list in the last node

D To mark the end of the list with a None value

💡 Hint

Think about how you can keep moving through nodes without stopping.

The last node points back to the head to create a loop, allowing traversal to cycle through the list repeatedly without a null end.