Traversal of Circular Linked List in DSA Javascript - Execution Trace

Concept Flow - Traversal of Circular Linked List

Start at head node

↓

Visit current node and process data

↓

Move to next node

↓

Is current node head again?

Yes→Stop traversal

↩Back to Visit current node

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

Execution Sample

DSA Javascript

let current = head;
do {
  console.log(current.data);
  current = current.next;
} while (current !== head);

Traverse the circular linked list starting from head and print each node's data until back to head.

Execution Table

Step	Operation	Current Node Data	Pointer Changes	Visual State
1	Start traversal at head	1	current = head (node with data 1)	1 -> 2 -> 3 -> 4 -> (back to 1)
2	Print current.data	1	No pointer change	1 -> 2 -> 3 -> 4 -> (back to 1)
3	Move to next node	2	current = current.next (node with data 2)	1 -> 2 -> 3 -> 4 -> (back to 1)
4	Print current.data	2	No pointer change	1 -> 2 -> 3 -> 4 -> (back to 1)
5	Move to next node	3	current = current.next (node with data 3)	1 -> 2 -> 3 -> 4 -> (back to 1)
6	Print current.data	3	No pointer change	1 -> 2 -> 3 -> 4 -> (back to 1)
7	Move to next node	4	current = current.next (node with data 4)	1 -> 2 -> 3 -> 4 -> (back to 1)
8	Print current.data	4	No pointer change	1 -> 2 -> 3 -> 4 -> (back to 1)
9	Move to next node	1	current = current.next (back to head)	1 -> 2 -> 3 -> 4 -> (back to 1)
10	Check if current == head	1	Condition true, stop traversal	Traversal complete

💡 Traversal stops when current node returns to head node.

Variable Tracker

Variable	Start	After Step 3	After Step 5	After Step 7	After Step 9	Final
current.data	1	2	3	4	1	Traversal ends

Key Moments - 3 Insights

Why do we use a do-while loop instead of a while loop?

Because we must process the head node before checking if we returned to it. See execution_table steps 1 and 10 where traversal starts at head and stops after returning to head.

What happens if the list has only one node?

The traversal prints that single node once and stops immediately after moving back to head, as current.next points to itself. This is shown by the condition in step 10.

Why does traversal stop when current equals head again?

Because in a circular list, returning to head means we completed a full circle. The check at step 10 ensures we don't loop infinitely.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of current.data at step 6?

A 4

B 2

C 3

D 1

💡 Hint

Check the 'Current Node Data' column at step 6 in the execution_table.

At which step does the traversal move back to the head node?

A Step 9

B Step 8

C Step 7

D Step 10

💡 Hint

Look at the 'Pointer Changes' column to see when current points back to head.

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

A 0 times

B 1 time

C 2 times

D Infinite times

💡 Hint

Refer to key_moments about single-node list behavior and the do-while loop logic.

Concept Snapshot

Traversal of Circular Linked List:
- Start at head node
- Visit and process current node
- Move to next node
- Stop when current node is head again
- Use do-while loop to ensure head is processed
- Prevent infinite loops by checking current == head

Full Transcript

Traversal of a circular linked list starts at the head node. We visit each node, process its data, then move to the next node. Because the list is circular, the last node points back to the head. We stop traversal when we return to the head node to avoid infinite looping. A do-while loop is used to ensure the head node is processed before the stopping condition is checked. This method works even if the list has only one node, which points to itself.

Practice

1. What is the main difference between traversing a circular linked list and a singly linked list?

easy

A. In a circular linked list, traversal requires a double pointer.

B. In a circular linked list, traversal stops when the starting node is reached again.

C. In a circular linked list, traversal stops when the last node's next is null.

D. In a circular linked list, traversal is done only backwards.

Solution

1. Step 1: Understand traversal stopping condition in singly linked list

   Traversal stops when the next pointer is null, indicating the end.

2. Step 2: Understand traversal stopping condition in circular linked list

   Traversal stops when the traversal reaches the starting node again, since the list loops back.

3. Final Answer:

   In a circular linked list, traversal stops when the starting node is reached again. -> Option B

4. Quick Check:

   Stopping condition differs: null vs start node [OK]

Hint: Remember: circular list loops back to start node [OK]

Common Mistakes:

• Stopping traversal at null in circular list
• Assuming circular list traversal is backward only
• Confusing traversal conditions with doubly linked lists

2. Which of the following is the correct syntax to start traversing a circular linked list in JavaScript assuming head is the starting node?

easy

A. let current = head; do { /* process current */ current = current.next; } while(current !== head);

B. let current = head; while(current.next !== null) { /* process current */ current = current.next; }

C. for(let current = head; current !== null; current = current.next) { /* process current */ }

D. let current = head; while(current !== null) { /* process current */ current = current.next; }

Solution

1. Step 1: Identify traversal loop for circular linked list

   Traversal must continue until current node loops back to head, so a do-while loop is suitable.

2. Step 2: Check syntax correctness

   let current = head; do { /* process current */ current = current.next; } while(current !== head); uses do-while with condition current !== head, correctly handling circular traversal.

3. Final Answer:

   let current = head; do { /* process current */ current = current.next; } while(current !== head); -> Option A

4. Quick Check:

   Use do-while to handle circular traversal [OK]

Hint: Use do-while to ensure at least one iteration [OK]

Common Mistakes:

• Using while with null condition in circular list
• Forgetting to process the head node
• Using for loop with null condition in circular list

3. What will be the output of the following code snippet?

class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

const head = new Node(1);
const second = new Node(2);
const third = new Node(3);

head.next = second;
second.next = third;
third.next = head; // circular link

let current = head;
do {
  console.log(current.data);
  current = current.next;
} while(current !== head);

medium

A. 1 2 3 1

B. Error: Infinite loop

C. 1 2 3 1 2 3 ... (infinite loop)

D. 1 2 3

Solution

1. Step 1: Understand the circular linked list structure

   Nodes 1, 2, 3 are linked circularly: third.next points back to head.

2. Step 2: Trace the do-while loop output

   Loop prints current.data and moves current to next until current equals head again. It prints 1, 2, 3 then stops.

3. Final Answer:

   1 2 3 -> Option D

4. Quick Check:

   Loop prints nodes once until back to start [OK]

Hint: do-while prints all nodes once in circular list [OK]

Common Mistakes:

• Expecting infinite loop output
• Printing head node twice
• Confusing do-while with while loop behavior

4. Identify the error in the following circular linked list traversal code:

let current = head;
while(current !== head) {
  console.log(current.data);
  current = current.next;
}

medium

A. The loop skips the last node.

B. The loop causes an infinite loop.

C. The loop never executes because current equals head initially.

D. The code throws a runtime error due to null reference.

Solution

1. Step 1: Analyze initial condition of the while loop

   current is initialized to head, so current !== head is false at start.

2. Step 2: Understand loop execution

   Since condition is false initially, loop body never executes, so no traversal happens.

3. Final Answer:

   The loop never executes because current equals head initially. -> Option C

4. Quick Check:

   While condition false at start means zero iterations [OK]

Hint: Check initial loop condition carefully in circular traversal [OK]

Common Mistakes:

• Using while instead of do-while for circular lists
• Assuming loop runs at least once
• Ignoring initial condition impact

5. Given a circular linked list where each node contains an integer, how would you find the sum of all node values without getting stuck in an infinite loop?

hard

A. Use a do-while loop starting at head, add node values, stop when current equals head again.

B. Use a while loop checking for current.next !== null to sum values.

C. Use recursion without a base case to sum values.

D. Traverse nodes until current is null, summing values.

Solution

1. Step 1: Choose traversal method suitable for circular list

   Use do-while loop to ensure all nodes are visited once, stopping when current returns to head.

2. Step 2: Sum node values during traversal

   Initialize sum to 0, add current.data each iteration, move to next node until loop ends.

3. Final Answer:

   Use a do-while loop starting at head, add node values, stop when current equals head again. -> Option A

4. Quick Check:

   Do-while loop prevents infinite traversal in circular list [OK]

Hint: Stop traversal when current node equals start node [OK]

Common Mistakes:

• Using null check in circular list traversal
• Forgetting to stop at head node again
• Using recursion without base case causing infinite calls