Detect if a Linked List is Circular in DSA Go - Build from Scratch

Detect if a Linked List is Circular

📖 Scenario: Imagine you have a chain of connected train cars. Sometimes, the last car connects back to an earlier car, making a loop. We want to check if the train cars form such a loop.

🎯 Goal: You will build a simple linked list of train cars and write code to check if the list loops back on itself (is circular).

📋 What You'll Learn

Create a linked list with exactly 4 nodes named head, node2, node3, and node4

Add a boolean variable isCircular to store the result

Write a function detectCircular that returns true if the list is circular, otherwise false

Print the result using fmt.Println(isCircular)

💡 Why This Matters

🌍 Real World

Circular linked lists are used in real systems like music playlists that repeat, or in scheduling tasks that cycle through repeatedly.

💼 Career

Understanding how to detect loops in linked lists helps in debugging memory leaks and infinite loops in software development.

1

Create a linked list with 4 nodes

Create a struct type called Node with an integer field value and a pointer field next to Node. Then create 4 nodes named head, node2, node3, and node4 with values 1, 2, 3, and 4 respectively. Link them so that head.next = node2, node2.next = node3, and node3.next = node4. Set node4.next to nil.

DSA Go

package main

import "fmt"

type Node struct {
    value int
    next  *Node
}

// Create 4 nodes and link them
// Your code here

Hint

Define the Node struct first. Then create each node with &Node{value: X}. Link nodes by setting the next field.

2

Add a boolean variable to store circular check result

Inside the main function, create a boolean variable called isCircular and set it to false initially.

DSA Go

package main

import "fmt"

type Node struct {
    value int
    next  *Node
}

func main() {
    head := &Node{value: 1}
    node2 := &Node{value: 2}
    node3 := &Node{value: 3}
    node4 := &Node{value: 4}

    head.next = node2
    node2.next = node3
    node3.next = node4
    node4.next = nil

    // Create a boolean variable isCircular and set it to false
    // Your code here
}

Hint

Just add isCircular := false inside main.

3

Write a function to detect if the linked list is circular

Write a function called detectCircular that takes a pointer to Node called head and returns a boolean. Use two pointers named slow and fast starting at head. Move slow by one step and fast by two steps in a loop. If fast or fast.next becomes nil, return false. If slow equals fast at any point, return true. Then, in main, set isCircular = detectCircular(head).

DSA Go

package main

import "fmt"

type Node struct {
    value int
    next  *Node
}

func detectCircular(head *Node) bool {
    // Your code here
}

func main() {
    head := &Node{value: 1}
    node2 := &Node{value: 2}
    node3 := &Node{value: 3}
    node4 := &Node{value: 4}

    head.next = node2
    node2.next = node3
    node3.next = node4
    node4.next = nil

    isCircular := false

    // Call detectCircular and assign to isCircular
    // Your code here
}

Hint

Use two pointers moving at different speeds to detect a loop. If they meet, the list is circular.

4

Print the result of circular detection

Add a line in main to print the value of isCircular using fmt.Println(isCircular).

DSA Go

package main

import "fmt"

type Node struct {
    value int
    next  *Node
}

func detectCircular(head *Node) bool {
    slow := head
    fast := head

    for fast != nil && fast.next != nil {
        slow = slow.next
        fast = fast.next.next
        if slow == fast {
            return true
        }
    }
    return false
}

func main() {
    head := &Node{value: 1}
    node2 := &Node{value: 2}
    node3 := &Node{value: 3}
    node4 := &Node{value: 4}

    head.next = node2
    node2.next = node3
    node3.next = node4
    node4.next = nil

    isCircular := false

    isCircular = detectCircular(head)

    // Print the value of isCircular
    // Your code here
}

Hint

Use fmt.Println(isCircular) to show the result.

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