Traversal of Circular Linked List in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a circular linked list?

A circular linked list is a linked list where the last node points back to the first node, forming a circle. There is no null at the end.

beginner

How do you know when to stop traversing a circular linked list?

You stop when you reach the starting node again after moving forward. This prevents infinite loops.

intermediate

Why can't you use 'null' to stop traversal in a circular linked list?

Because the last node points back to the first node, there is no 'null' to indicate the end. You must track the start node instead.

beginner

Show the basic steps to traverse a circular linked list.

1. Start at the head node.
2. Visit the current node.
3. Move to the next node.
4. Repeat until you reach the head node again.

intermediate

What is a common mistake when traversing a circular linked list?

A common mistake is forgetting to check if you returned to the start node, causing an infinite loop.

In a circular linked list, what does the last node point to?

A Null

B Itself

C A random node

D The first node

In a circular linked list, the last node points back to the first node, creating a loop.

When traversing a circular linked list, how do you know when to stop?

A When you reach the starting node again

B When the next node is null

C After visiting 10 nodes

D When the node value is zero

Traversal stops when you reach the starting node again to avoid infinite loops.

What happens if you forget to check for the start node during traversal?

A Traversal stops early

B Infinite loop occurs

C Traversal skips nodes

D You get an error

Without checking for the start node, traversal never ends, causing an infinite loop.

Which data structure is best described as nodes connected in a circle?

A Singly linked list

B Doubly linked list

C Circular linked list

D Array

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

What is the first step in traversing a circular linked list?

A Start at the head node

B Check if the list is empty

C Move to the last node

D Set current node to null

Traversal always starts at the head node in a circular linked list.

Explain how to traverse a circular linked list safely without causing an infinite loop.

Think about how to detect the end since there is no null.

Describe the difference between traversing a singly linked list and a circular linked list.

Focus on how the end of the list is identified.

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