leetcode 141 环形链表 哈希表+快慢指针

题目很容易理解，就是判断链表中有没有环。

解法一：快慢指针
快指针每次走两步，慢指针每次走一步，如果有环，在环上快指针每次多走一步，一定会相遇。

/**
 * 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) {
        if(!head)return false;
        ListNode *slow = head, *fast = head->next;

        while(slow && fast)
        {
            fast = fast->next;
            if(fast)fast = fast->next;
            slow = slow->next;
            if(fast == slow)return true;
        }
        return false;
    }
};

同一起点做法
如果让快慢指针都从头开始，按照上面的做法，在只有一个元素时会报错。
针对这种情况，可以先判断再走慢指针。

/**
 * 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 *slow = head, *fast = head;
        while(slow && fast)
        {
            fast = fast->next;
            if(fast)fast = fast->next;
            if(slow == fast)return true;
            slow = slow->next;
        }
        return false;
    }
};

解法二：哈希表

哈希表，甚至红黑树都是可以存指针的，没想到吧，其实指针的哈希还蛮好做的。

/**
 * 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) {
        unordered_set<ListNode*> s;

        while(head)
        {
            if(s.count(head))return true;
            s.insert(head);
            head = head->next;
        }

        return false;
    }
};