Detect if a Linked List is Circular in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the linked list is empty before starting the loop.

DSA Go

if head == [1] {
    return false
}

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

Anil

B0

Cnull

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 or null instead of nil causes compile errors.

Checking for None is invalid in Go.

In Go, the empty pointer for a linked list node is nil. Checking head == nil ensures the list is empty.

2fill in blank

medium

Complete the code to move the slow pointer one step forward in the linked list.

DSA Go

slow = slow.[1]

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

Anext

Bprev

Cchild

Dlink

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev moves backward, which is incorrect for singly linked lists.

Using child or link are not standard field names.

The next field points to the next node in the linked list. Moving slow to slow.next advances it by one node.

3fill in blank

hard

Fix the error in the condition to detect if the fast pointer or its next is nil.

DSA Go

if fast == [1] || fast.next == [1] {
    return false
}

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

Anull

BNone

Cnil

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using null or None instead of nil.

Using 0 instead of nil.

In Go, nil is used to check if a pointer is empty. Using null or None causes errors.

4fill in blank

hard

Fill both blanks to move the fast pointer two steps ahead safely.

DSA Go

fast = fast.[1].[2]

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

Anext

Bprev

Clink

Dchild

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev moves backward, which is wrong.

Using different field names causes errors.

To move fast two steps ahead, we access fast.next.next. Both blanks should be next.

5fill in blank

hard

Fill all three blanks to complete the function that detects if a linked list is circular using Floyd's cycle detection.

DSA Go

func isCircular(head *Node) bool {
    if head == [1] {
        return false
    }
    slow, fast := head, head
    for fast != [2] && fast.next != [2] {
        slow = slow.[3]
        fast = fast.next.next
        if slow == fast {
            return true
        }
    }
    return false
}

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

Anil

Bnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for nil causes errors.

Moving slow incorrectly breaks the detection.

Not checking fast and fast.next for nil causes runtime panic.

The function checks if the list is empty by comparing head to nil. It then loops while fast and fast.next are not nil. The slow pointer moves one step by slow.next. If slow meets fast, the list is circular.

Practice

1. What does it mean if a linked list is circular?

easy

A. The last node points back to one of the previous nodes, forming a loop

B. The linked list has no nodes

C. The linked list nodes are sorted in ascending order

D. The linked list has only one node

Solution

1. Step 1: Understand linked list structure

   A linked list is a chain of nodes where each node points to the next node.

2. Step 2: Define circular linked list

   If the last node points back to any previous node, it creates a loop, making the list circular.

3. Final Answer:

   The last node points back to one of the previous nodes, forming a loop -> Option A

4. Quick Check:

   Circular linked list means loop in nodes = D [OK]

Hint: Circular means last node links back inside list [OK]

Common Mistakes:

• Thinking circular means sorted list
• Confusing empty list with circular
• Assuming single node list is always circular

2. Which Go code snippet correctly checks if a linked list is circular using two pointers?

easy

A. for slow != nil && fast != nil { slow = slow.Next; fast = fast.Next; if slow == fast { return true } } return false

B. for slow != nil { slow = slow.Next; if slow == fast { return true } } return false

C. for slow != nil && fast != nil && fast.Next != nil { slow = slow.Next; fast = fast.Next.Next; if slow == fast { return true } } return false

D. for fast != nil && fast.Next != nil { fast = fast.Next.Next; if slow == fast { return true } } return false

Solution

1. Step 1: Understand Floyd's cycle detection

   Use two pointers: slow moves one step, fast moves two steps. If they meet, list is circular.

2. Step 2: Check code correctness

   for slow != nil && fast != nil && fast.Next != nil { slow = slow.Next; fast = fast.Next.Next; if slow == fast { return true } } return false correctly moves slow by one and fast by two steps and checks for equality inside the loop.

3. Final Answer:

   for slow != nil && fast != nil && fast.Next != nil { slow = slow.Next; fast = fast.Next.Next; if slow == fast { return true } } return false -> Option C

4. Quick Check:

   Two pointers moving at different speeds detect loop = B [OK]

Hint: Fast pointer moves twice, slow moves once to detect loop [OK]

Common Mistakes:

• Moving fast pointer only one step
• Not checking fast.Next for nil
• Checking slow == fast outside loop

3. What will be the output of this Go code snippet detecting circular linked list?

type Node struct { Val int; Next *Node }

func isCircular(head *Node) bool {
    slow, fast := head, head
    for fast != nil && fast.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
        if slow == fast {
            return true
        }
    }
    return false
}

// List: 1 -> 2 -> 3 -> 4 -> 2 (loop back to node with value 2)
node1 := &Node{1, nil}
node2 := &Node{2, nil}
node3 := &Node{3, nil}
node4 := &Node{4, nil}
node1.Next = node2
node2.Next = node3
node3.Next = node4
node4.Next = node2

fmt.Println(isCircular(node1))

medium

A. true

B. false

C. runtime error

D. infinite loop

Solution

1. Step 1: Analyze linked list structure

   The last node (node4) points back to node2, creating a loop.

2. Step 2: Trace Floyd's cycle detection

   Slow and fast pointers will eventually meet inside the loop, so function returns true.

3. Final Answer:

   true -> Option A

4. Quick Check:

   Loop exists, so output is true [OK]

Hint: Loop in list means function returns true [OK]

Common Mistakes:

• Assuming no loop returns true
• Confusing pointer equality with value equality
• Ignoring fast.Next nil check

4. Find the bug in this Go code that tries to detect if a linked list is circular:

func isCircular(head *Node) bool {
    slow, fast := head, head
    for fast != nil {
        slow = slow.Next
        fast = fast.Next.Next
        if slow == fast {
            return true
        }
    }
    return false
}

medium

A. The function should return false inside the loop when slow != fast

B. The loop condition should check fast.Next != nil to avoid nil pointer dereference

C. The slow pointer should move two steps instead of one

D. The fast pointer should start at head.Next instead of head

Solution

1. Step 1: Review loop condition

   The loop only checks fast != nil, but fast.Next might be nil causing runtime error on fast.Next.Next.

2. Step 2: Correct loop condition

   Adding fast.Next != nil in the loop condition prevents nil pointer dereference when accessing fast.Next.Next.

3. Final Answer:

   The loop condition should check fast.Next != nil to avoid nil pointer dereference -> Option B

4. Quick Check:

   Check fast and fast.Next to avoid errors [OK]

Hint: Always check fast.Next != nil before fast.Next.Next [OK]

Common Mistakes:

• Not checking fast.Next leads to runtime panic
• Moving slow pointer two steps is incorrect
• Returning false inside loop prematurely

5. Given a linked list where the last node points back to the head node, how can you modify the detection function to also return the length of the loop?

hard

A. Return the total number of nodes in the list without checking for loops

B. Count nodes while traversing from head until reaching nil

C. Use a map to store visited nodes and count duplicates

D. After detecting the loop, keep one pointer fixed and move the other until they meet again, counting steps

Solution

1. Step 1: Detect the loop using two pointers

   Use Floyd's cycle detection to find if slow and fast pointers meet inside the loop.

2. Step 2: Count loop length

   Once pointers meet, keep one pointer fixed and move the other pointer forward until it meets the fixed pointer again, counting the steps taken.

3. Final Answer:

   After detecting the loop, keep one pointer fixed and move the other until they meet again, counting steps -> Option D

4. Quick Check:

   Loop length = steps between pointer meetings [OK]

Hint: Count steps between pointer meetings after loop detected [OK]

Common Mistakes:

• Counting nodes until nil in circular list causes infinite loop
• Using map wastes extra memory
• Returning total nodes ignores loop length