Detect if a Linked List is Circular in DSA Go - Execution Trace

Concept Flow - Detect if a Linked List is Circular

Start at head

↓

Check if current is None?

Yes→List is NOT circular, STOP

No↓

Check if current.next == head?

Yes→List is circular, STOP

No↓

Move current to current.next

↓

Check if current is None?

Start from the head node and move through each node. If you reach None, the list is not circular. If you find a node pointing back to the head, the list is circular.

Execution Sample

DSA Go

func isCircular(head *Node) bool {
    if head == nil {
        return false
    }
    current := head.next
    for current != nil && current != head {
        current = current.next
    }
    return current == head
}

This code checks if the linked list loops back to the head node, indicating a circular list.

Execution Table

Step	Operation	Current Node	Pointer Changes	Visual State
1	Start at head	Node 1	None	1 -> 2 -> 3 -> None
2	Move current to head.next	Node 2	current = head.next	1 -> 2 -> 3 -> None
3	Check current != nil and current != head	Node 2	No change	1 -> 2 -> 3 -> None
4	Move current to current.next	Node 3	current = current.next	1 -> 2 -> 3 -> None
5	Check current != nil and current != head	Node 3	No change	1 -> 2 -> 3 -> None
6	Move current to current.next	nil	current = current.next	1 -> 2 -> 3 -> None
7	Check current != nil and current != head	nil	No change	1 -> 2 -> 3 -> None
8	Exit loop, current == nil	nil	No change	1 -> 2 -> 3 -> None (Not Circular)

💡 current reached nil, so list is NOT circular

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	Final
head	Node 1	Node 1	Node 1	Node 1	Node 1
current	nil	Node 2	Node 3	nil	nil

Key Moments - 3 Insights

Why do we start current at head.next instead of head?

Starting at head.next avoids immediately detecting the head as circular. The execution_table row 2 shows current moves to head.next before the loop.

What happens if the list is empty (head == nil)?

The function returns false immediately because there is no node to traverse. This is before step 1 in the execution_table.

Why does the loop check current != nil and current != head?

To stop if we reach the end (nil) meaning not circular, or if we loop back to head meaning circular. Rows 3, 5, and 7 show these checks.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of current at Step 4?

A Node 1

B Node 3

C Node 2

D nil

💡 Hint

Check the 'Current Node' column at Step 4 in execution_table

At which step does the condition current != nil become false?

A Step 5

B Step 6

C Step 7

D Step 8

💡 Hint

Look at the 'Current Node' column and condition checks in execution_table rows 6 and 7

If the list was circular, which step would detect it?

A When current == head

B When current == nil

C At the start before loop

D Never detected

💡 Hint

Refer to the concept_flow and execution_table condition checking current == head

Concept Snapshot

Detect if a linked list is circular by traversing nodes starting from head.next.
If traversal reaches nil, list is not circular.
If traversal reaches head again, list is circular.
Check current != nil and current != head in loop condition.
Return true if circular, false otherwise.

Full Transcript

To detect if a linked list is circular, start from the head node and move through each node one by one. We begin checking from the node after head to avoid false detection. If at any point the current node is nil, it means the list ends and is not circular. If the current node points back to the head, the list is circular. The code loops until one of these conditions is met and returns true or false accordingly.

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