One approach to detect the cycle in a linked list is Floyd's cycle-finding algorithm, also known as hare and tortoise algorithm. In this approach, two pointers, a slow pointer and a fast pointer, traverse the linked list. If the linked list contains a cycle, eventually, the fast pointer will catch up with the slow pointer.

Here's the code for implementing Floyd's algorithm:

```
bool hasCycle(ListNode *head) {
    if (head == nullptr || head->next == nullptr) {
        return false;
    }
    ListNode* slow = head;
    ListNode* fast = head->next;
    while (slow != fast) {
        if (fast == nullptr || fast->next == nullptr) {
            return false;
        }
        slow = slow->next;
        fast = fast->next->next;
    }
    return true;
}
```

The time complexity of this algorithm is O(n) and the space complexity is O(1), where n is the number of nodes in the linked list.
Data head, la testa di un elenco collegato, determina se l'elenco collegato contiene un ciclo. C'è un ciclo in una lista collegata se c'è qualche nodo nella lista che può essere raggiunto di nuovo seguendo continuamente il puntatore successivo. Internamente, pos è usato per denotare l'indice del nodo a cui è connesso il puntatore next di tail. Si noti che pos non viene passato come parametro. Restituisce vero se c'è un ciclo nell'elenco collegato. Altrimenti, restituisce false.