Linked List Cycle

 Given head, the head of a linked list, determine if the linked list has a cycle in it.

There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next pointer. Internally, pos is used to denote the index of the node that tail's next pointer is connected to. Note that pos is not passed as a parameter.

Return true if there is a cycle in the linked list. Otherwise, return false.

Input: head = [3,2,0,-4], pos = 1

Output: true

#include <iostream>
#include <set>

 //Definition for singly-linked list.
 struct ListNode {
      int val;
     ListNode *next;
     ListNode(int x) : val(x), next(NULL) {}
 };

class Solution {
public:
    bool hasCycle(ListNode* head) {
        ListNode* curr = head;
        // Create a set of type Linked List
        std::set<ListNode*> set_node{};

        // Return if list is empty
        if (curr == NULL) {
            return false;
        }

        // Loop through the linked list
        while (curr) {
            // Check if the node is present in the list. There are two methods.
#if 0
            /* First method - you can use "count". Count returns 1 if there is duplicate, otherwise
            it returns 0 */
             if (set_node.count(curr)) {
                 return true;
             }

             or
#endif

            /* Second method - you can use "find". Find returns the iterator to the position where duplicate is, otherwise
            it returns the end of the list */
            if (set_node.find(curr) != set_node.end()) {
                return true;
            }

            // Insert the node to the list
            set_node.insert(curr);
            // Move to the next node.
            curr = curr->next;

        }

        return false;
    }
};