leetcode_141_142_环形链表

环形链表

描述

简单

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

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

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

进阶：

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

示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：

• 链表中节点的数目范围是 [0, 104]
• -105 <= Node.val <= 105
• pos 为 -1 或者链表中的一个 有效索引 。

解题

可以使用字典（哈希），将每个节点放在字典里，如果有重复，说明有环

使用快慢指针，快指针一次走两步，慢指针一次走一步，如果有环的话，快慢指针会在环里相遇

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

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        fast = head
        slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                return True
        return False

环形链表II

描述

中等

返回入环的第一个节点

解题

依然使用快慢指针，所以，快指针走过的路程是慢指针的两倍

设从head到环入口距离为a，环的长度为b，快慢指针肯定会在环中相遇，设走过环入口c的距离后相遇

那么快指针共走过的路程为s1 ，其中，m表示快指针走了几圈的环，肯定是大于等于一圈才能套慢指针的圈，然后赶上它

• s1 = a + m * b + c

慢指针走过的路程为s2

• s2 = a + c

然后s1 = 2 * s2

所以 a + m * b + c = 2 * (a + c)

得到a = mb - c

然后再定义一个新指针，只要新指针走a步就到了环入口

新指针和快指针同时一次走一步，当快指针走了a步，新指针也走了a步（当然可以慢指针走，此时快慢指针是重合的）

当快指针走了a步时，也可以看作时快指针走了mb - c步，加上快指针原来走过的路程，相当于是

• s1 + mb - c = a + mb + c + mb - c = a + 2mb

即快指针走了2m圈的环，新指针和快指针同时到达了环入口

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

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        fast = head
        slow = head
        flag = 0  	# 判断是否有环
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                flag = 1
                break

        if not flag:
            return None

        new = head
        while new != fast:
            new = new.next
            fast = fast.next
            
        return new