A linked list is said to contain a cycle if any node is visited more than once while traversing the list. Given a pointer to the head of a linked list, determine if it contains a cycle. If it does, return . Otherwise, return .

Example

refers to the list of nodes

The numbers shown are the node numbers, not their data values. There is no cycle in this list so return .

refers to the list of nodes

There is a cycle where node 3 points back to node 1, so return .

Function Description

Complete the has_cycle function in the editor below.

It has the following parameter:

SinglyLinkedListNode pointer head: a reference to the head of the list Returns

int: if there is a cycle or if there is not

What is wrong with the below code -> It works in leedcode but fails here if head is None: return False #if head and head.next is None: # return False slow = head fast = head.next while slow: if slow == fast: return True if fast and fast.next: fast = fast.next.next else: return False slow = slow.next return False

Here is my C++ code using a vector.

bool has_cycle(SinglyLinkedListNode* head) {
    
    vector<SinglyLinkedListNode*> node_addresses;
    
    while (head != nullptr){
        node_addresses.push_back(head);
        head = head->next;
        
        for (auto itr : node_addresses){
            if (head == itr){
                return 1;
            }
        }
    }
    
    return 0;
}

Is there something wrong with this problem in python? I tried this Tortise vs Hare solution:

def has_cycle(head):
    hare = head
    turtle = head 
    while hare and hare.next :
        hare = hare.next.next
        turtle = turtle.next 
        if hare == turtle:
            return 1
    return 0

as well as a more "standard of just using a set:

def has_cycle(head):
    seen = set()
    current = head 
    while current:
        if id(current) in seen:
            return 1
        seen.add(id(current))
        current = current.next
    return 0

and neither worked

Hashmap implementation in Python In the worst case it will have an On complexity

def has_cycle(head):
    hashmap = dict()
    while head:
        hashmap[head] = hashmap.get(head, 0) + 1
        if hashmap[head] > 1:
            return 1
        head = head.next
    return 0