算法通关村第一关-链表黄金挑战环形链表问题

环形链表

描述 :  给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。

LeetCode 141.环形链表 :

141. 环形链表

牛客 BM6 判断链表中是否有 : 

分析 :

方法一 : 判断是否有环，最容易的方法是使用Hash，遍历的时候将元素放入到map中，如果有环一定会发生碰撞。发生碰撞的位置也就是入口的位置，因此这个题so easy。

方法二 :  确定是否有环，最有效的方法就是双指针，一个快指针(一次走两步)，一个慢指针(一次走一步)。如果快的能到达表尾就不会有环，否则如果存在环，则慢指针一定会在某个位置与快指针相遇。这就像在操场长跑，一个人快一个人慢，只要时间够，快的一定能在某个时候再次追上慢的人(也就是所谓的套圈)。

解析 :

哈希

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode node = head;
        HashSet<ListNode> set = new HashSet<>();

        while(node != null){
            if(!set.contains(node)){
                set.add(node);
            }else{
                return true;
            }
            node = node.next;
        }
        return false;
    }
}

快慢指针

import java.util.*;
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null || head.next == null){
            return false;
        }
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next!= null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                return true;
            }
        }

        return false;
    }
}

环形链表入口节点

牛客BM7 链表中环的入口结点 : 

 LeetCode 142.环形链表2

142. 环形链表 II

 解析 : 

先说结论先按照快慢方式寻找到相遇的位置(假如为下图中Z)，然后将两指针分别放在链表头 (X)和相遇位置 (Z)，并改为相同速度推进，则两指针在环开始位置相遇 (Y)。

先看假如一圈就遇到的情况

1.找环中相汇点。分别用fast、slow表示快慢指针，slow每次走一步，fast就走两步，直到在环中的某个位置相会，假如是图中的Z。

2.第一次相遇 : 那么我们可以知道fast指针走了a+b+c+b步 , slow指针走了a+b步 , 那么:

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

因此此时让slow从Z继续向前走，fast回到起点，两个同时开始走(两个每次都走一步)，一次走一步那么它们号终会相遇在v当，正是环的起始点 . 

如果多圈之后才相遇

设链表中环外部分的长度为 a。slow 指针进入环后，又走了 b 的距离与 fast 相遇。此时，fast 指针已经走完了环的 n 圈，因此它走过的总距离为:

Fast: a+n(b+c)+b=a+(n+1)b+nc

根据题意，任意时刻，fast 指针走过的距离都为 slow 指针的 2 倍。因此，我们有:

a+(n+1)b+nc=2(a+b)
由于b+c 就是环的长度，假如为LEN，则:
a=c+(n-1)LEN

这说明什么呢?说明相遇的时候快指针在环了已经转了(n-1)LEN圈，如果n-1就退化成了我们上面说的一圈的场景。假如n是2，3，4，..呢，这只是说明当一个指针p1重新开始从head走的时候，另一个指针p2从Z点开始，两者恰好在入口外相遇，只不过p2要先在环中转n-1圈

import java.util.*;
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null || head.next == null){
            return false;
        }

        while(fast != null){
            slow = slow.next;
            if(fast.next != null){
                fast = fast.next.next;
            }else{
                return false;
            }

            if(slow == fast){
                ListNode p = head;
                while(p != slow){
                    p = p.next;
                    slow = slow.next;
                }
                return p;
            }
        }
        return null;
    }
}

这关就到这里 , 下一关见!