9 链表中环的入口结点--剑指offer--python实现

1. 题目描述

  描述：给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

2. 题目解析

2.1 考察问题

  本问题考察的是链表的遍历和快慢指针应用。
  环的入口节点，说明是遍历链表，第一次重复的结点。

2.2 解决方法

1. 遍历链表，list计数
      遍历链表，使用list来记录已经遍历的元素，如果遍历过程中，第一次发现某个元素已经存在，则该元素必然为环的入口节点。
      时间复杂度为$O(n)$,空间复杂度为$O(n)$
2. 快慢指针，规律发现
   基于以下两个结论：
   (1) 设置快慢指针，假如有环，他们最后一定相遇。
   (2) 两个指针分别从链表头和相遇点继续出发，每次走一步，最后一定相遇与环入口。
   证明结论1：设置快慢指针fast和low，fast每次走两步，low每次走一步。假如有环，两者一定会相遇（因为low一旦进环，可看作fast在后面追赶low的过程，每次两者都接近一步，最后一定能追上）。
   证明结论2：
   设：
     链表头到环入口长度为–a
     环入口到相遇点长度为–b
     相遇点到环入口长度为–c
   如下图所示：
   
   则：相遇时
     快指针路程=a+(b+c)k+b ，k>=1 其中b+c为环的长度，k为绕环的圈数（k>=1,即最少一圈，不能是0圈，不然和慢指针走的一样长，矛盾）。
     慢指针路程=a+b
     快指针走的路程是慢指针的两倍，所以：
     （a+b）*2=a+(b+c)k+b
   化简可得：
     a=(k-1)(b+c)+c 这个式子的意思是： 链表头到环入口的距离=相遇点到环入口的距离+（k-1）圈环长度。其中k>=1,所以k-1>=0圈。所以两个指针分别从链表头和相遇点出发，最后一定相遇于环入口。
      时间复杂度为$O(n)$,空间复杂度为$O(1)$

2.3 优化分析

  链表的问题优化，往往是通过类似快慢指针的应用，多个指针配合，或者规律发现来解决。不太像数组一样，有二分查找那样的固有算法。
  所以链表操作更加偏技巧性，而非算法性，这点我先写在这里，也许不对，以后再来纠正。

3. 代码实现

3.1 遍历链表，list计数

 -*- coding:utf-8 -*-
 class ListNode:
     def __init__(self, x):
         self.val = x
         self.next = None

class Solution:
    def EntryNodeOfLoop(self, pHead):### 时间复杂度为 O(n) 空间复杂度为O(n)
        if not pHead:
            return None
        list_nodes = []
        while pHead:
            if list_nodes.count(pHead):
                return pHead
            else:
                list_nodes.append(pHead)
            pHead = pHead.next
        return None

3.2 快慢指针，规律发现

 -*- coding:utf-8 -*-
 class ListNode:
     def __init__(self, x):
         self.val = x
         self.next = None

class Solution:
    def EntryNodeOfLoop(self, pHead):
        # write code here
        if not pHead:
            return None
        slow = pHead
        fast = pHead
        meet = None
        while slow and fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                meet = slow ## 记录相遇点
                break
        if not meet: ## 没相遇则位None
            return None
        slow = pHead  ## slow和fast分别从pHead和meet出发，一步一步走，必然能够找到入口
        fast = meet
        while slow != fast: 
            slow = slow.next
            fast = fast.next
        return slow