链表中环的入口结点

思路一：借助一个list

遍历链表，将遍历过的结点都放入list中，当遇到重复结点时，说明找到了环的入口

public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        ArrayList<ListNode> list = new ArrayList<>();
        while (pHead != null){
            if (list.size() > 0 && list.contains(pHead)){
                return pHead;
            }else {
                list.add(pHead);
            }
            pHead = pHead.next;
        }
        return null;
    }

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

思路二：

假设x为环前面的路程（黑色路程），a为环入口到相遇点的路程（蓝色路程，假设顺时针走）， c为环的长度（蓝色+橙色路程）

当快慢指针相遇的时候：

此时慢指针走的路程为x + m * c + a

快指针走的路程为x + n * c + a

（m,n分别为走过环的圈数）

2slow = fast         2 * ( x + m*c + a ) = (x + n *c + a)

从而可以推导出：x = (n - 2 * m )*c - a = (n - 2 *m -1 )*c + c - a

即环前面的路程 = 数个环的长度（为可能为0） + c - a

什么是c - a？这是相遇点后，环后面部分的路程。（橙色路程）

所以，我们可以让一个指针从起点A开始走，让一个指针从相遇点B开始继续往后走，2个指针速度一样，那么，当从原点的指针走到环入口点的时候（此时刚好走了x）从相遇点开始走的那个指针也一定刚好到达环入口点。所以2者会相遇，且恰好相遇在环的入口点。

最后，判断是否有环，且找环的算法复杂度为：

时间复杂度：O(n)

空间复杂度：O(1)

public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        if (pHead.next == null){
            return null;
        }
        ListNode slow = pHead.next;
        ListNode fast = pHead.next.next;
        while (fast != slow){
            fast = fast.next.next;
            slow = slow.next;
        }
        //相遇
        slow = pHead;
        while (slow != fast){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

小结：只要存在环，那么两个速度不一样的指针肯定会相遇，所以速度比可以是任意的

思路三：断链法

从上图中可以看出，环的入口结点和其他结点的区别：环的入口结点是有两个指针指向的，其他结点除了头结点都是只有一个指针指向的，使用断链法，在当前结点访问完毕后，断掉指向当前结点的指针。因此，最后一个被访问的结点一定是入口结点。

代码：

    public ListNode EntryNodeOfLoop(ListNode pHead){
        ListNode pre = pHead;
        ListNode walk = pre.next;
        if (walk == null){
            return null;
        }
        while (walk != null){
            pre.next = null;
            pre = walk;
            walk = pre.next;
        }
        return pre;
    }

参考：https://www.nowcoder.com/questionTerminal/253d2c59ec3e4bc68da16833f79a38e4