【31】环形链表 | 环形链表 II（LeetCode 141 | 142）

环形链表

问题描述

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

解题思路

第一个想法就是沿着next遍历并做标记，当访问到标记为已访问的结点则说明链表中有环。

/**
 * 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) {
        while(head){
        //题目中给的结点值最大是10000，所以以1000000作为访问过的标记
            if(head->val == 1000000) return true;
            head->val = 1000000;
            head = head->next;
        }
        return false;
    }
};

时间复杂度：O（n）
空间复杂度：O（1）

但是这样做破坏了原链表，而且在实际应用中不一定知道结点数值的取值范围，所以不可取。

根据官解，对结点做标记应采用hash表：用哈希表来存储所有已经访问过的节点。每次到达一个节点，如果该节点已经存在于哈希表中，则说明该链表是环形链表，否则就将该节点加入哈希表中。

class Solution {
public:
    bool hasCycle(ListNode *head) {
        unordered_set<ListNode*> seen;
        while (head != nullptr) {
            if (seen.count(head)) {
                return true;
            }
            seen.insert(head);
            head = head->next;
        }
        return false;
    }
};

时间复杂度：O（n）
空间复杂度：O（n）

官解还提供了一种很有意思的解法——快慢指针：

class Solution {
public:
    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;
    }
};

时间复杂度：O（n）
空间复杂度：O（1）

环形链表 II

问题描述

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

进阶：

你是否可以使用 O(1) 空间解决此题？

解题思路

有了上一题的基础就很简单了，若是用hash表存储已访问结点，则返回第一个被标记的结点即可。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        unordered_set<ListNode*> seen;
        while (head) {
            if (seen.count(head)) {
                return head;
            }
            seen.insert(head);
            head = head->next;
        }
        return NULL;
    }
};

时间复杂度：O（n）
空间复杂度：O（n）

快慢指针：

俩指针第一次相遇的地方不一定是环的第一个结点，所以应当根据相遇时俩指针走过的路程关系求出环和不是环的链表部分的长度，从而定位到环的第一个结点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
         ListNode* fast = head;
         ListNode* slow = head;
        while (1) {
            if (!fast || !fast->next) return NULL;
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) break;
        }
        fast = head;
        while (slow != fast) {
            slow = slow->next;
            fast = fast->next;
        }
        return fast;
    }
};

小总结

关于链表的题做到目前为止用到过以下方法：

1、快慢指针 ：找链表中的中位数结点、删除链表倒数第K个结点、判断链表是否有环等；

2、增加头结点：需要对链表的每个结点进行相同的操作时可以增加一个头结点进行统一；

3、hash表：用来标记结点；

4、分离-合并链表：比如分隔链表和复制带随机指针的链表，都可以往分离在合并或者合并再分离的方向思考；

5、递归：随缘吧。