Traversal of Circular Linked List in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start traversal from the head node.

DSA Javascript

let current = [1];

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

Ahead

Bnull

Ctail

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Starting traversal from tail instead of head.

Using null as starting point.

Traversal of a circular linked list starts from the head node.

2fill in blank

medium

Complete the condition to stop traversal after one full cycle.

DSA Javascript

do {
  console.log(current.data);
  current = current.next;
} while (current !== [1]);

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

Acurrent

Bnull

Ctail

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using null as stopping condition in circular list.

Stopping traversal too early.

Traversal stops when current comes back to the head node, completing the cycle.

3fill in blank

hard

Fix the error in the traversal loop to avoid infinite loop.

DSA Javascript

while (current !== [1]) {
  console.log(current.data);
  current = current.next;
}

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

Anull

Bhead

Ctail

Dcurrent

Attempts:

3 left

💡 Hint

Common Mistakes

Using null as stopping condition causes infinite loop.

Not updating current inside the loop.

In circular linked list, loop should stop when current reaches head again to avoid infinite loop.

4fill in blank

hard

Fill both blanks to complete the traversal function for circular linked list.

DSA Javascript

function traverseCircularList(head) {
  if (!head) return;
  let current = head;
  do {
    console.log(current.data);
    current = current.[1];
  } while (current !== [2]);
}

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

Anext

Bhead

Cprev

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev instead of next for traversal.

Stopping condition not checking head.

Traversal moves to the next node and stops when it reaches the head again.

5fill in blank

hard

Fill all three blanks to create a function that collects data from a circular linked list into an array.

DSA Javascript

function collectData(head) {
  if (!head) return [];
  let result = [];
  let current = [1];
  do {
    result.push(current.[2]);
    current = current.[3];
  } while (current !== head);
  return result;
}

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

Ahead

Bdata

Cnext

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Starting from tail instead of head.

Pushing next instead of data.

Using prev instead of next.

Start from head, push data of current node, move to next node, stop when back at head.

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