Traversal of Circular Linked List in DSA Python - Execution Trace

Concept Flow - Traversal of Circular Linked List

Start at head node

↓

Visit current node and process data

↓

Move to next node

↓

Check if current node is head again?

Yes→Stop traversal

No↓

Visit current node and process data

Start from the head node, visit each node, move to the next, and stop when you return to the head.

Execution Sample

DSA Python

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

# Assume head is the start of circular linked list
current = head
while True:
    print(current.data)
    current = current.next
    if current == head:
        break

Traverse a circular linked list starting from head and print each node's data once.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Start at head	1->2->3->4->(back to 1)	current = head (Node 1)	1 -> 2 -> 3 -> 4 -> (back to 1)
2	Print current.data	1->2->3->4->(back to 1)	current = Node 1	Output: 1
3	Move to next node	1->2->3->4->(back to 1)	current = current.next (Node 2)	Pointer at Node 2
4	Print current.data	1->2->3->4->(back to 1)	current = Node 2	Output: 2
5	Move to next node	1->2->3->4->(back to 1)	current = current.next (Node 3)	Pointer at Node 3
6	Print current.data	1->2->3->4->(back to 1)	current = Node 3	Output: 3
7	Move to next node	1->2->3->4->(back to 1)	current = current.next (Node 4)	Pointer at Node 4
8	Print current.data	1->2->3->4->(back to 1)	current = Node 4	Output: 4
9	Move to next node	1->2->3->4->(back to 1)	current = current.next (Node 1)	Pointer back at Node 1
10	Check if current == head	1->2->3->4->(back to 1)	current == head is True	Stop traversal

💡 Traversal stops when current pointer returns to head node.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 7	After Step 9	Final
current	Node 1 (head)	Node 2	Node 3	Node 4	Node 1 (head)	Traversal stops

Key Moments - 3 Insights

Why do we stop traversal when current equals head again?

Because in a circular linked list, nodes loop back to head. Stopping when current == head prevents infinite looping, as shown in execution_table row 10.

What if the list has only one node?

Traversal prints that single node once and stops immediately after moving back to head, same logic as rows 1-3 but with only one node.

Why do we use a 'while True' loop with a break instead of a normal condition?

Because we must visit the head node first before checking if we returned to it. The break happens after printing and moving, ensuring all nodes are visited once, as in execution_table steps 2-10.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'current' after Step 5?

A Node 2

B Node 3

C Node 4

D Node 1

💡 Hint

Check the 'Pointer Changes' column at Step 5 in execution_table.

At which step does the traversal stop because current equals head again?

A Step 10

B Step 8

C Step 9

D Step 7

💡 Hint

Look for the step where 'current == head is True' in execution_table.

If the circular linked list had only one node, how many times would the loop print the node's data?

A Twice

B Zero times

C Once

D Infinite times

💡 Hint

Refer to key_moments explanation about single-node list traversal.

Concept Snapshot

Traversal of Circular Linked List:
- Start at head node
- Visit and process current node
- Move to next node
- Stop when current returns to head
- Use while True with break to handle circular condition
- Ensures each node visited exactly once

Full Transcript

Traversal of a circular linked list starts at the head node. We visit the current node, process its data, then move to the next node. Because the list loops back to the head, we stop traversal when the current node pointer returns to the head. This prevents infinite loops. The code uses a while True loop with a break condition after moving to the next node and checking if it is the head again. This way, all nodes are visited exactly once. For a single-node list, the traversal prints the node once and stops immediately after returning to head.