142. Linked List Cycle II

题目：

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

Note: Do not modify the linked list.

Follow up:
Can you solve it without using extra space?

给定一个链表的头指针，问你能不能只用常数的空间快速判断一个链表是不是有环，如果有环，返回环的起始位置。

代码：

不能用额外的空间，所以必须通过遍历，判断有没有环的存在。

经典的判断方法（百度很多哦）：

对于判断链表是否有环，方法很简单，用两个指针，一开始都指向头结点，一个是快指针，一次走两步，一个是慢指针，一次只走一步，当两个指针重合时表示存在环了。

根据此方法：

如图，a代代表链表起始位置到环开始位置的距离；x代表环起始位置到快慢指针节点相遇点的距离；c代表环的长度。

假设慢指针和快指针在9处第一次相遇，于是又慢指针走的距离 s_slow=a+x，

快指针会多走一圈之后来追上慢指针，于是走的距离应该是      s_fast=a+n*c+x（快指针可能走了n圈）

因为快指针的速度是慢指针的2倍，所以距离s_fast=2*s_slow.于是有：a+x+nc = 2*(a+x) =>nc = a + x => a = (n-1)c+c-x

当慢指针走距离a时候，快指针走了n-1圈加c-x的距离。

所以如果把慢指针放回起点S，让他重启走完a距离，快指针从相遇点9继续走，他们第二次肯定会相遇在4，也就是环的起点。

因为满指针走完a的时间里，快指针刚好走完了整数圈加c-x的距离，肯定会停在圈的起点。

于是可以根据这个规律，求出环的起点：

java代码，不复杂，就是分别循环到两次，找到第二次相遇的点：

public ListNode detectCycle(ListNode head) {
        if(head==null){return null;}
        ListNode Slower = head;
        ListNode Faster = head;
        //循环到第一次相遇为止
        while(Faster!=null && Slower != null){
            Slower = Slower.next;
            Faster = Faster.next;
            if(Faster!=null){
                Faster = Faster.next;
            }
            else{
                return null;
            }
            System.out.println("Faster: "+Faster.val+"   "+"Slower: "+Slower.val);
            if(Slower==Faster){
                Slower = head;
                //循环到第二次相遇
                 while(Slower != Faster){
                     Slower = Slower.next;
                     Faster = Faster.next;
                     System.out.println("LittleCycle: Faster: "+Faster.val+"   "+"Slower: "+Slower.val);                  
                 }
                 return Slower;
            }
        }
        return null;    
    }

输出输出结果，构建如上图所示的环：

FirstCycle： Faster: 3   Slower: 2
FirstCycle： Faster: 5   Slower: 3
FirstCycle： Faster: 7   Slower: 4
FirstCycle： Faster: 9   Slower: 5
FirstCycle： Faster: 11   Slower: 6
FirstCycle： Faster: 5   Slower: 7
FirstCycle： Faster: 7   Slower: 8
FirstCycle： Faster: 9   Slower: 9
SecondCycle： Faster: 10   Slower: 2
SecondCycle： Faster: 11   Slower: 3
SecondCycle： Faster: 4   Slower: 4
环的起点： 4

问题代码逻辑不复复杂，但是解题思路很关键，也是百度学习了很久，当然测试也需要构建存在环的链表这种数据结构。

简单写下我的链表创建方法，也是凑了好久凑出来的，还在寻找好的方案：

先递归创建一个链表，然后把最后一个对象指向其中的一个(cycle=4)，构建成环:)

本想直接递归创建一个带环的列表，但是很难在ListNode类中实现（至少我还没想出来：（），先这样用吧：

public class ListNode {
     int val;
     ListNode next;
     ListNode(int x) {
     val = x;
     next = null;
     }

//递归调用makeListNode，创建列表。
     ListNode head;
     public ListNode(int[] array){
         head=makeListNode(array,0);
     }

//根据对象的值获取链表中某个对象        
     public ListNode getNode(int value){
         ListNode temp = this.head;
         while(temp.val != value){
              temp = temp.next;
         }
         return temp;
     }

/**
         * 采用递归的方式创建链表
         * 传入的是链表的数组表示法
         * 构造后是链表的链表表示法
         */
        public static ListNode makeListNode(int[] array,int index){
            if(index < array.length){
                int value=array[index];      
                ListNode t=new ListNode(value);                
                t.next=makeListNode(array,++index);
                return t;
            }
            return null;
        }
}

public static void main(String[] args) {
        // TODO Auto-generated method stub
        Solution a = new Solution();      
        int[] arr = {1,2,3,4,5,6,7,8,9,10,11};
        int cycle = 4;        
        ListNode list = new ListNode(arr);

　　　//把链表最后一位指向链表中第cycle个对象
        if(cycle>0){
            for (int i = 0;i<arr.length;i++){
                 if(cycle==arr[i]){
                     list.getNode(arr[arr.length-1]).next = list.getNode(cycle);
                 }
            }
        }        
        
        ListNode x = a.detectCycle(list.head);
        if(x==null){
            System.out.println("yes");
        }
        else{
            System.out.println(x.val);    
        }

最后，提交结果：