昨日回顾

昨天我们初步介绍了链表的相关知识，并且通过列举数组和链表的差异，进行了比较学习。之后介绍了链表涉及的相关题型，并举例了第一种链表的第一种删除类题目。那么今天我们就来看看链表的第二类题目：链表的环与交点

环形链表

链表的环是一类在链表中很爱考察的热门题目，今天针对这类题目，带着大家一起学习下。

对于一般的链表，会存在一个头节点，然后根据链表指针一直遍历到链表的结尾即null。但有一种环形链表，这种链表将本该指向null的指针指向了链表自身的某一个节点，构成了一个环形链表。本该是一个非正常的指向，却引出了这类环形链表的问题。

环形链表的结构和构成我们了解了，但如何判断一个链表是否有环呢？让我们来想一个场景。

假设链表的结尾指向的节点是头节点这种特殊场景，那就构成了一个看起来像圆环的链表。我们将这个链表抽象为操场一圈400米的跑道，当前一群运动健儿正在进行10000米的长跑比赛。 大家出于同一起跑点，由于需要跑25圈难免有体育系的运动健将冲在第一名，速度上快最后一名很多。

如果是一个直道，那么他们必然越拉越远，但就因为是环道，所以当第一名快最后一名400米距离时他们相遇了。

那么，我们是不可以将这种现象运用在环形链表上呢？我们构造两个指针，一快一慢，如果他们最终相遇了，代表是环形链表，如果他们没有相遇，则表示链表没有环。所以在做题的时候，我们要开动脑筋，把题目从抽象的概念转化为实际的场景，更有助于解题。

我们知道了要使用快慢指针，但是到底要怎么定义快慢呢？很简单，慢指针一次走一格，快指针一次走两格就行了。当然之前说过机试题一般不会考链表，因为链表都是可以转化为其他数据结构而使用单纯循环解决的，让我们先找一道力扣的上的环形链表入门题看看吧。

141.环形链表

https://leetcode-cn.com/problems/linked-list-cycle/solution/141huan-xing-lian-biao-pythonji-he-yu-ku-1yuu/

难度：简单

题目：

给定一个链表，判断链表中是否有环。

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

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

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？

提示：

• 链表中节点的数目范围是 [0, 10^4]
• -10^5 <= Node.val <= 10^5
• pos 为 -1 或者链表中的一个 有效索引 。

示例：

网络异常，图片无法展示

|

分析

先考虑常规场景，设置一个set集合，然后开始while循环，条件为head存在。

每次遍历链表都判断是否存在集合内，存在返回True， 不存在则将当前链表加入到集合中。

最终若while循环结束返回False。

如果考虑O1的空间复杂度，上面的解法不就满足了。需要开始快慢指针的场景。

设置初始指针slow = fast = head,

然后slow = slow.next  fast = fast.next.next

即慢的一次走一步，快的一次走两步。如果快的追上了慢的，代码为循环链表。

解题1 集合判断：

Python:

class Solution:
    def hasCycle(self, head):
        d = set()
        while head:
            if head in d:
                return True
            else:
                d.add(head)
                head = head.next
        return False

Java:

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode li = head;
        HashSet s = new HashSet();
        while (li != null){
            if (s.contains(li)){
                return true;
            }
            s.add(li);
            li = li.next;
        }
        return false;
    }
}

解题2 快慢指针：

Python:

class Solution:
    def hasCycle(self, head):
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                return True
        return False

Java:

public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode left = head;
        ListNode right = head;
        while (right != null && right.next != null) {
            left = left.next;
            right = right.next.next;
            if (left == right) {
                return true;
            }
        }
        return false;
    }
}

有了这道简单题目的基础，我们就可以进阶的学习书上的22题了。来看看题吧。

剑指offerII022.链表中环的入口节点

https://leetcode-cn.com/problems/c32eOV/

难度：中等

题目

给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

提示：

• 链表中节点的数目范围在范围 [0, 10 ^ 4] 内
• -10 ^ 5 <= Node.val <= 10 ^ 5
• pos 的值为 -1 或者链表中的一个有效索引

进阶：是否可以使用 O(1) 空间解决此题？

示例

分析

• 141.环形链表

看过了141题的环形链表，相信我们对于判断环形链表已经没有什么问题了，但是这道题要我们求的是环形链表的入口节点，这又该如何解题呢？

之前就说了，遇到链表题画图是一个很好的解决办法。让我们画一个图，通过图形分析这道题吧。

假设快慢指针在W点相遇，此时慢指针走过的路程为x+y，快指针走过的路程为x+y+n(y+z)。

为什么慢指针走过y就必然与快指针相遇，而不是慢指针走过y+m(y+z)呢？

• 首先，由于快指针一定先进入环内，这点毋庸置疑。
• 而且，快指针是慢指针速度的二倍，即慢指针走完一圈，快指针可以走两圈
• 所以不论慢指针入环时，快指针在哪一点，快指针都可以在慢指针未走过一圈时追上慢指针。

而由于快指针走过的节点数是慢指针的二倍，所以得到公式：

(x + y) * 2 = x + y + n (y + z)

两边抵消 x+y，得到 x + y = n (y + z)

由于我们最终要求的是x，所以 x = n (y + z) - y

然而,此时慢指针所走过的路程刚好为y，如果此时有一个指针point从头开始走向环，即x路程

那么，慢指针刚好要走过的就是 n (y + z) - y + y  = n (y + z)

即 point 走x的距离到达环的入口的时刻，刚好为slow走过n圈到达入口，两个指针相遇？

得到这个结论，那么题目就迎刃而解了！

解题

Python:

class Solution:
    def detectCycle(self, head):
        slow, fast = head, head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                point = head
                while point!=slow:
                    point = point.next
                    slow = slow.next
                return point
        return None

Java:

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                ListNode point = head;
                while (point != slow) {
                    point = point.next;
                    slow = slow.next;
                }
                return point;
            }
        }
        return null;
    }
}

环形链表的知识，我们就总结到这里，下来遇到同类型的题目，大家记得思路不清晰的时候多画画图思考下，也许就迎刃而解了。

两个链表相交

除了链表自身成环，还有一种题目是针对两个链表的焦点查找题目。遇到这种题目该如何思考呢？让我们来看看下面这道题目。

剑指offerII023.两个链表的第一个重合节点

https://leetcode-cn.com/problems/3u1WK4/solution/shua-chuan-jian-zhi-offer-day12-lian-bia-m5nz/

难度：简单

题目

给定两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

提示：

• listA 中节点数目为 m
• listB 中节点数目为 n
• 0 <= m, n <= 3 * 10 ^ 4
• 1 <= Node.val <= 10 ^ 5
• 0 <= skipA <= m
• 0 <= skipB <= n
• 如果 listA 和 listB 没有交点，intersectVal 为 0
• 如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

进阶：能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案？

示例

分析

这道题比较容易想到的是，创建一个hash表，然后循环依次A，将A的所有节点添加至Hash表中。

再循环依次B，每次判断B的当前节点是否在hash表中。

代码如下：

class Solution:
    def getIntersectionNode(self, headA, headB):
        d = {}
        while headA:
            d[headA] = headA
            headA = headA.next
        while headB:
            if d.get(headB):
                return headB
            headB = headB.next
        return None

这样的思路可以通过，但是题目说了程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

hash表构造了额外的O(n)空间复杂度，那么如何来实现使用O(1)的时间复杂度完成呢？

让我们根据示例1画张草图来分析下：

1. 假设相交前A链表的长度为x,B链表的长度为z
2. 两个链表相交的点为图中的w
3. 相交后共同的长度为y。
4. 我们分别创建p1、p2两个指针指向A、B
5. 当p1或者p2走到头时，则将指针重新指向另外的一个链表。
6. 当p1、p2相等时终止，返回p1或p2就是第一个相交节点。
7. 因为p1、p2走过的路程都是x+y+z！

所以我们可以使用上图的方式，通过双指针的解法，来完成这道题目。

解题

Python:

class Solution:
    def getIntersectionNode(self, headA, headB):
        x, y = headA, headB
        while x != y:
            x = x.next if x else headB
            y = y.next if y else headA
        return x

Java:

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1 = headA;
        ListNode p2 = headB;
        while (p1 != p2){
            p1 = p1 != null?p1.next:headB;
            p2 = p2 != null?p2.next:headA;
        }
        return p1;
    }
}

今天关于链表的环与交点题目，就分享到这里，记得打卡哦！