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 DescriptionComplete the has_cycle function in the editor below.It has the following parameter:SinglyLinkedListNode pointer head: a reference to the head of the listReturnsint: if there is a cycle or if there is notNote: If the list is empty, will be null.Input FormatThe code stub reads from stdin and passes the appropriate argument to your function. The custom test cases format will not be described for this question due to its complexity. Expand the section for the main function and review the code if you would like to figure out how to create a custom case.ConstraintsSample InputReferences to each of the following linked lists are passed as arguments to your function:Sample Output01ExplanationThe first list has no cycle, so return .The second list has a cycle, so return .

The problem is asking to determine if a linked list has a cycle. A linked list has a cycle if while traversing, you visit a node that you have already visited before.

Here is a step by step solution:

1. Initialize two pointers, slow and fast, to point to the head of the linked list.

2. Move slow by one node and fast by two nodes in each iteration.

3. If the linked list has a cycle, the fast pointer will eventually meet the slow pointer. If they meet, return 1 indicating that a cycle exists.

4. If the fast pointer reaches the end of the linked list, that means the linked list doesn't have a cycle. In this case, return 0.

Here is the Python code for the above steps:

def has_cycle(head):
    if head is None:
        return 0

    slow = head
    fast = head

    while fast is not None and fast.next is not None:
        slow = slow.next
        fast = fast.next.next

        if slow == fast:
            return 1

    return 0

In the above code, head is the head of the linked list. The function has_cycle returns 1 if there is a cycle in the linked list, otherwise it returns 0. The while loop in the function is used to move the slow and fast pointers. If at any point, the slow and fast pointers meet, that means there is a cycle in the linked list. If the fast pointer reaches the end of the linked list, that means there is no cycle.