剑指offer：链表中环的入口结点（变型：判断链表是否有环）

题目：一个链表中包含环，请找出该链表的环的入口结点。（变型题：链表中是否有环？）

分析：A->B->C->D->B->C->D

方法一：首先从头节点开始，依次遍历单链表的每一个节点。每遍历到一个新节点，就从头节点重新遍历新节点之前的所有节点，用新节点ID和此节点之前所有节点ID依次作比较。如果发现新节点之前的所有节点当中存在相同节点ID，则说明该节点被遍历过两次，链表有环；如果之前的所有节点当中不存在相同的节点，就继续遍历下一个新节点，继续重复刚才的操作。

例如这样的链表：A->B->C->D->B->C->D， 当遍历到节点D的时候，我们需要比较的是之前的节点A、B、C，不存在相同节点。这时候要遍历的下一个新节点是B，B之前的节点A、B、C、D中恰好也存在B，因此B出现了两次，判断出链表有环，且B为环的入口。

假设从链表头节点到入环点的距离是D，链表的环长是S。D+S是链表总节点数。那么算法的时间复杂度是0+1+2+3+….+(D+S-1) = (D+S-1)*(D+S)/2 ， 可以简单地理解成 O(N*N)。而此算法没有创建额外存储空间，空间复杂度可以简单地理解成为O(1)。

方法二：使用set来保存节点值，每添加一个就查找是否存在相同结点，发现HashSet当中存在相同节点ID，则说明链表有环，第一个存在的结点即为入口，返回即可，否则就添加进set，指针指向下一个结点。

package Solution43;

import java.util.HashSet;
import java.util.Set;

//一个链表中包含环，请找出该链表的环的入口结点。
public class Solution {
    public class ListNode {
        int val;
        ListNode next = null;

        ListNode(int val) {
            this.val = val;
        }
    }
    //用set存放节点值，返回第一个重复的值即为入口
    public ListNode EntryNodeOfLoop(ListNode pHead) {
        if(pHead==null) return null;
        Set<Integer> set=new HashSet<>();
        while(pHead!=null){
            int value=pHead.val;
            if(set.contains(value)){
                return pHead;
            }else{
                set.add(value);
            }
            pHead=pHead.next;
        }
        return null;
    }
}

假设从链表头节点到入环点的距离是D，链表的环长是S。而每一次HashSet查找元素的时间复杂度是O(1), 所以总体的时间复杂度是1*(D+S)=D+S，可以简单理解为O(N)。而算法的空间复杂度还是D+S-1，可以简单地理解成O(N)。

方法三：

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

当快慢指针相遇的时候：

此时慢指针走的路程为Sslow = x + m * c + a
快指针走的路程为Sfast = x + n * c + a
2 Sslow = Sfast
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)

/**
 * Definition for ListNode.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int val) {
 *         this.val = val;
 *         this.next = null;
 *     }
 * }
 */


public class Solution {
    /*
     * @param head: The first node of linked list.
     * @return: The node where the cycle begins. if there is no cycle, return null
     */
    public ListNode detectCycle(ListNode head) {
        // write your code here
        if(head==null || head.next==null||head.next.next==null)   return null;
        //fast和head本来都是从head开始，分别fast往前2步和slow往前1步其实是一样的。因为下面还是要做slow=slow.next和fast=fast.next.next.
        ListNode fast,slow;
        slow=head.next;
        fast=head.next.next;
        while(fast!=slow){
            if(fast.next==null || fast.next.next==null)
                return null;
            slow=slow.next;
            fast=fast.next.next;
        }
        //此时有环
        fast=head;
        while(fast!=slow){
            fast=fast.next;
            slow=slow.next;
        }
        return fast;
    }
}

变型：判断单链表是否有环

首先创建两个指针1和2（在java里就是两个对象引用），同时指向这个链表的头节点。然后开始一个大循环，在循环体中，让指针1每次向下移动一个节点，让指针2每次向下移动两个节点，然后比较两个指针指向的节点是否相同。如果相同，则判断出链表有环，如果不同，则继续下一次循环。

例如链表A->B->C->D->B->C->D，两个指针最初都指向节点A，进入第一轮循环，指针1移动到了节点B，指针2移动到了C。第二轮循环，指针1移动到了节点C，指针2移动到了节点B。第三轮循环，指针1移动到了节点D，指针2移动到了节点D，此时两指针指向同一节点，判断出链表有环。

此方法也可以用一个更生动的例子来形容：在一个环形跑道上，两个运动员在同一地点起跑，一个运动员速度快，一个运动员速度慢。当两人跑了一段时间，速度快的运动员必然会从速度慢的运动员身后再次追上并超过，原因很简单，因为跑道是环形的。

public boolean hasLoop(ListNode n){
        ListNode slow = n.next;
        ListNode fast = n.next.next;
        while(fast!=null){
            if(slow==fast) return true;//当两个指针重逢时，说明存在环，否则不存在。
            slow=slow.next;
            fast=fast.next.next;
            if(fast == null)return false;//不存在环时，退出
        }
        return true; //如果tmp2为null，说明元素只有一个，也可以说明是存在环
    }