Leetcode 142 Linked List Cycle Ⅱ

**Leetcode 142 Linked List Cycle Ⅱ

题目描述

Given a linked list, return the node where the cycle begins. If there is no cycle, return null.

To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list.

Note: Do not modify the linked list.

Example 1:

Input: head = [3,2,0,-4], pos = 1
Output: tail connects to node index 1
Explanation: There is a cycle in the linked list, where tail connects to the second node.

Example 2:

Input: head = [1,2], pos = 0
Output: tail connects to node index 0
Explanation: There is a cycle in the linked list, where tail connects to the first node.

Example 3:

Input: head = [1], pos = -1
Output: no cycle
Explanation: There is no cycle in the linked list.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/linked-list-cycle-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路解析

与Leetcode 141 Linked List Cycle思路类似，只不过返回值变成了环的首结点，如果没有环，则返回None

• 思路一：利用哈希表，代码如下：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if not head or not head.next:
            return None
        nodes = {}
        while head:
            if nodes.get(head):
                return head
            else:
                nodes[head] = 1
                head = head.next
        return None

时间复杂度$O(N)$，空间复杂度$O(N)$

• 思路二：快慢指针

常规的快慢指针只能判断链表是否有环，但是floyd算法，可以根据快指针和慢指针相遇的结点来计算出环的首结点。

参考官方题解，代码如下：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        start = head
        if not start or head.next is None:
            return None
        end = self.intersectNode(head)
        if end is None:
            return None
        while start != end:
            start = start.next
            end = end.next
        return start
    
    # 求快慢指针相遇结点
    def intersectNode(self, head):
        if not head or head.next is None:
            return None
        low = head 
        fast = head
        while fast and fast.next:
            low = low.next
            fast = fast.next.next
            if low == fast:
                return low
        return None

与Leetcode 141 Linked List Cycle不同的是，快慢指针的起始结点不同。

时间复杂度$O(N)$，空间复杂度$O(1)$，待研究floyd