Traversal of Circular Linked List in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start traversal from the head node.

DSA Rust

let mut current = [1];

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

Anext

Btail

CNone

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Starting traversal from tail instead of head.

Using None which means no node.

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

2fill in blank

medium

Complete the code to move to the next node during traversal.

DSA Rust

current = current.[1];

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

Anext

Bprev

Chead

Dtail

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' which goes backward.

Using 'head' or 'tail' which are not node pointers.

To traverse, move to the next node using the 'next' pointer.

3fill in blank

hard

Fix the error in the loop condition to stop after one full cycle.

DSA Rust

while current != [1] { /* process node */ current = current.next; }

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

Ahead

Bcurrent

Ctail

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using None which never occurs in circular lists.

Using tail which is not the cycle start.

In a circular linked list, stop when you reach the head again after a full cycle.

4fill in blank

hard

Fill both blanks to correctly print all nodes in the circular linked list.

DSA Rust

let start = [1];
let mut current = start;
loop {
    println!("{}", current.data);
    current = current.[2];
    if current == start {
        break;
    }
}

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

Ahead

Btail

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using tail as start which is incorrect.

Using prev to move forward which goes backward.

Start from head and move to next node until back to head.

5fill in blank

hard

Fill both blanks to create a function that traverses and collects data from a circular linked list.

DSA Rust

fn traverse_circular_list(head: Option<Box<Node>>) -> Vec<i32> {
    let mut result = Vec::new();
    if head.is_none() {
        return result;
    }
    let start = head.as_ref().unwrap();
    let mut current = start;
    loop {
        result.push(current.data);
        current = current.[1];
        if current == start [2] ;;
    }
}

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

Anext

Breturn

Cbreak

D;

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'return' inside loop which exits function early.

Forgetting semicolon causing syntax error.

Move to next node, break loop when back to start, and end statement with semicolon.

Practice

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

easy

A. In a circular linked list, nodes have two pointers instead of one.

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

C. In a circular linked list, nodes are stored in an array.

D. In a circular linked list, nodes cannot be traversed.

Solution

1. Step 1: Understand the structure of a circular linked list

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

2. Step 2: Compare with a regular singly linked list

   A regular singly linked list ends with a null pointer, not looping back.

3. Final Answer:

   In a circular linked list, the last node points back to the first node. -> Option B

4. Quick Check:

   Last node points to first node = A [OK]

Hint: Remember: circular means last node links back to start [OK]

Common Mistakes:

• Thinking circular lists have two pointers per node
• Confusing circular linked list with doubly linked list
• Assuming nodes are stored in arrays

2. Which Rust code snippet correctly starts traversal of a circular linked list from the head node?

easy

A. let mut current = head;
loop {
println!("{}", current.data);
current = current.next.unwrap();
if current == head { break; }
}

B. let mut current = head;
while current != None {
println!("{}", current.data);
current = current.next;
}

C. for node in head {
println!("{}", node.data);
}

D. let mut current = head;
loop {
println!("{}", current.data);
current = current.next.unwrap();
}

Solution

1. Step 1: Identify correct loop structure for circular traversal

   let mut current = head; loop { println!("{}", current.data); current = current.next.unwrap(); if current == head { break; } } uses a loop that breaks when current returns to head, correctly handling circular traversal.

2. Step 2: Check other options for errors

   let mut current = head; while current != None { println!("{}", current.data); current = current.next; } uses while with None check, which is incorrect for circular lists. for node in head { println!("{}", node.data); } uses for loop on head, invalid syntax. let mut current = head; loop { println!("{}", current.data); current = current.next.unwrap(); } loops infinitely without break.

3. Final Answer:

   let mut current = head; loop { println!("{}", current.data); current = current.next.unwrap(); if current == head { break; } } -> Option A

4. Quick Check:

   Loop until current == head = A [OK]

Hint: Use loop with break when current equals head [OK]

Common Mistakes:

• Using while with None check in circular list
• Forgetting to break loop on returning to head
• Using invalid for loop syntax on linked list

3. What will be the output of the following Rust code that traverses a circular linked list with nodes containing values 10, 20, 30?

let mut current = head;
loop {
    print!("{} ", current.data);
    current = current.next.unwrap();
    if current == head { break; }
}

medium

A. Runtime error due to infinite loop

B. 10 20 30 10

C. 20 30 10

D. 10 20 30

Solution

1. Step 1: Understand traversal logic

   The loop prints current.data, moves to next, and breaks when current equals head again.

2. Step 2: Trace the output

   Starting at 10, prints 10, moves to 20, prints 20, moves to 30, prints 30, moves to 10 (head), breaks loop.

3. Final Answer:

   10 20 30 -> Option D

4. Quick Check:

   Print nodes once until back to head = D [OK]

Hint: Stop printing when current node equals head again [OK]

Common Mistakes:

• Printing extra head node again after loop
• Assuming infinite loop without break
• Starting traversal from wrong node

4. Identify the bug in this Rust code snippet for traversing a circular linked list:

let mut current = head;
while current != head {
    println!("{}", current.data);
    current = current.next.unwrap();
}

medium

A. The code causes infinite loop because no break condition.

B. The unwrap() causes panic if next is None.

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

D. The println! macro is used incorrectly.

Solution

1. Step 1: Analyze loop condition

   The while loop condition is current != head, but current starts as head, so condition is false immediately.

2. Step 2: Understand effect on execution

   Loop body never runs, so no traversal happens.

3. Final Answer:

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

4. Quick Check:

   Loop condition false at start = B [OK]

Hint: Check initial loop condition matches traversal logic [OK]

Common Mistakes:

• Using while current != head instead of loop with break
• Ignoring that current starts at head
• Assuming unwrap() always safe without checking

5. You want to sum all values in a circular linked list of integers using Rust. Which approach correctly avoids infinite loops and sums all nodes exactly once?

hard

A. Use a loop starting at head, add current.data, move to next, break when current == head again.

B. Use a while loop checking current != None, add current.data, move to next.

C. Use recursion without base case to traverse nodes and sum values.

D. Use a for loop over head assuming it implements Iterator.

Solution

1. Step 1: Understand circular list traversal for summation

   We must visit each node once and stop when we return to head to avoid infinite loops.

2. Step 2: Evaluate options

   Use a loop starting at head, add current.data, move to next, break when current == head again. uses loop with break on current == head, correctly summing once. Use a while loop checking current != None, add current.data, move to next. uses None check which is invalid for circular lists. Use recursion without base case to traverse nodes and sum values. causes infinite recursion. Use a for loop over head assuming it implements Iterator. assumes Iterator trait which is not standard for linked lists.

3. Final Answer:

   Use a loop starting at head, add current.data, move to next, break when current == head again. -> Option A

4. Quick Check:

   Loop with break on head = C [OK]

Hint: Break loop when current node equals head to avoid repeats [OK]

Common Mistakes:

• Using None checks in circular lists
• Recursing without base case causing stack overflow
• Assuming linked list implements Iterator trait