算法通关村 | 第一关 | 黄金拓展篇

        前边我们了解了关于链表的一些基础操作和实用技巧，接下来我们将要对之前的知识点加以总结，把它们运用到一下更复杂的场景中（如环）。不多说话，直接上实战！

说到链表中的环，我们先来了解一下它到底是什么！

什么是链表中的环？

        通俗的来讲，链表中的环就是链表中某个节点，指向了另一个结点，从而就构成了一个环型结构。再具体一点就是，一个链表中某个节点的 "next" 指针指向了链表中的其他节点，而这个节点之前已经出现过，那么就形成了一个环。这样的链表被称为带环链表（cyclic linked list）。

        具体的环还分为单向链表和双向链表中的环，更深层次的就请各位大gie自行了解吧~~~

我们先来通过一道题目来初步了解一下链表中的环（以下关于环的问题都是基于单向链表中的） 

 

判断链表中是否有环

题目链接： 141. 环形链表 - 力扣（LeetCode）

题目介绍：

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

 思路：

之前我们了解了双指针法，那我就哈希法来解一下吧~~

 大致思路就是把链表中的元素放到集合中，如果有环就一定会发生碰撞。

值得注意的是：当我们遇到了要快速判断一个元素是否在集合中出现时，要考虑使用哈希法。但哈希法也是牺牲了空间来换取了时间，因为我们要使用额外的数组，set 或者是 map 来存放数据，才能实现快速查找。

具体代码如下：

public class Solution {
    public boolean hasCycle(ListNode head) {
        // 用哈希解决出现过的元素
        ListNode pos = head;
        boolean tmp = false;
        Set<ListNode> seted = new HashSet<ListNode>();
        while(pos != null){
            if(seted.contains(pos)){
                tmp = true;
                break;
            }else{
                seted.add(pos);
            }
            pos=pos.next;
        }
        return tmp;
    }
}

 再来使用双指针法解答一下：

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;
    }
}

可能有的大gei不理解为什么可以使用双指针法，那么我们就以此为题来深入了解一下“环”。

---

判断链表是否有环

        上面已经给出了代码，可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。

        那为什么有环，fast 和 slow 就一定会相遇呢？为什么不 "都是过客" 呢？

         首先确定的一点是，有环的话，fast 一定是先进入环的，然后接在环中移动，如果fast指针和slow指针相遇的话，一定是在环中相遇。

所以为什么快慢指针就一定会相遇呢？

 一切皆在图中

 当fast和slow相距一个空格时，如情况1，它们会在3处相遇 

 当fast和slow相距两个空格时，如情况2，下一次移动fast到3，slow到4，情况就又和1相同，所以只要有环，fast 和 slow 就一定会相遇。

        再通俗一点来讲就是，快指针在以相对于慢指针每次移动一个节点的靠近，在环内快指针一定会追到慢指针。

 知道有环了，我们又该如何确定环的入口呢？

假设从头结点到环形入口节点(X->Y) 的节点数为 a。 环形入口节点到 fast指针与slow指针相遇节点(Y->Z) 节点数为b。 从相遇节点 再到环形入口节点(Z->Y)节点数为 c。

 所以快慢相遇时：

• slow指针走过的节点数为:  a  + b
• fast指针走过的节点数：a + b + n (b + c)
• n为fast指针在环内走了n圈才遇到slow指针
• （b+c）为 一圈内节点的个数

又因为 快指针一下走两个节点，慢指针走一个节点， 所以快指针走的节点数 = 慢指针走的节点数 * 2.

即 （a+b）* 2  = a + b + n(b + c)

    两边消去一个a+b得，a+b = n(b+c)

    因为是找环的入口，所以又可以化简为：a=(n-1)(b+c)+c    (n>=1).

举个特殊的例子，当n=1，即fast只转了一圈时，此时 a=c ，这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。如 idx1 从 fast 出发，idx2 从 head 出发。

以此类推，当n>1 时，即当slow到达环的入口时，fast 已经在环中转了 n 圈了，相比于n=1时，fast多转了 n-1 圈。

还又一点要补充的是，为什么 slow 的步数是 固定的 (a + b)，而不是 k(a+b) 呢？也就是说为什么慢指针一定会在第一圈就被快指针追上？

我们来发散一下思维，当slow如环了，fast一定也在环中了，当slow走了一圈时，fast走过的结点是slow的二倍，且fast是一步步的追slow的。大概的过程如下图所示：

 再思考思考就会慢慢理解其中的关系。

---

 

所以说到这里，我们就可以尝试解决，一下下面这道题：

题目链接：142. 环形链表 II - 力扣（LeetCode）

思路上面都讲了，就直接看代码了~（直接来吧！） 

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){// 有环
                ListNode idx1 = fast;
                ListNode idx2 = head;
                // 根据a=c
                while(idx1 != idx2){
                    idx1 = idx1.next;
                    idx2 = idx2.next;
                }
                return idx1;
            }
        }
        return null;
    }
}

有没有了解啥是链表中的环？ 相信各位大gei们一定都会了（小弟抱拳）。

后续还会继续分享我的算法学习记录！加油！