Detect Loop in Linked List in C, C++, Java & Python – Code with Explanation & Examples in Short and Simple

   

C Program

struct Node {
    int val;
    struct Node* next;
};

int hasLoop(struct Node* head) {
    struct Node *slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) return 1;
    }
    return 0;
}

C Output

Input: 1 → 2 → 3 → 4 → 2 (loop to node with value 2)
Output: Loop detected (1)

C++ Program

struct Node {
    int val;
    Node* next;
    Node(int x) : val(x), next(nullptr) {}
};

bool hasLoop(Node* head) {
    Node *slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) return true;
    }
    return false;
}

C++ Output

Input: Loop from node 4 back to 2
Output: true

JAVA Program

class Node {
    int val;
    Node next;
    Node(int x) { val = x; }
}

boolean hasLoop(Node head) {
    Node slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
        if (slow == fast) return true;
    }
    return false;
}

JAVA Output

Input: Linked list with a loop
Output: true

Python Program

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def has_loop(head):
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True
    return False

Python Output

Input: 1 → 2 → 3 → 4 → 2 (loop)
Output: True

In-Depth Explanation

Example

Assume you build the following linked list: 1 → 2 → 3 → 4 → 5, and then you make 5.next = 2. The list will loop back to node 2, and then it proceeds in an infinite loop: 2 → 3 → 4 → 5 → 2. It would never terminate under normal traversal. This is the type of bug that loop detection allows you to detect earlier.

Real-Life Analogy

Suppose you are on a circular path in a stadium. If you walk and see that you are passing the same individuals or trees over and over again, you're in a loop. This is what the Floyd's Algorithm emulates. A slow pointer walks (1 step), and a fast one runs (2 steps). If there is a loop, the fast one will lap the slow one, just like in real races.

Why It Matters

Finding a loop in a linked list is important in real-world systems to avoid infinite loops, memory leaks, or crashes. Most bugs in OS kernels, network packet routing, and blockchain transaction verification are caused by accidental cycles in data structures. This algorithm makes you more defensive and accurate in coding.

What You Learn from This

You learn how to efficiently use multiple pointers and how a smart traversal approach can find cycles without using additional memory. It also instructs you on the necessity of handling edge-cases in linked lists, including null checks and preventing pointer overwrites. This algorithm enhances your competence in solving dynamic and pointer-manipulation problems.

Interview Relevance and Real Projects

This is one of the most common interview questions for firms such as Google, Amazon, Meta, and TCS. It usually generates follow-up questions such as: "Find the start node of the cycle," or "Delete the cycle if detected." In systems that exist in real life, it comes in handy when used in navigation software, circular task planners, streaming data cycles, and blockchain transaction loops.

SEO-Optimized Explanation

Detection of a loop in a linked list is an important issue in data structure that verifies circular references with Floyd's Cycle Detection Algorithm. The method employs two pointers traveling at varied paces to ascertain whether the list has a cycle or not. This algorithm avoids infinite loops, crashes, and memory corruption in computing systems. It's a building block for programmers who use dynamic memory and pointer-intensive code. Study loop detection in linked lists in C, C++, Java, and Python allows beginners to develop a strong foundation in traversal methods and laid groundwork for intricate real-world situations and high-level programming interviews.