一、题目描述
给定一个链表,返回链表开始入环的第一个节点。
如果链表无环,则返回 null。为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。
如果 pos 是 -1,则在该链表中没有环。
注意,pos 仅仅是用于标识环的情况,并不会作为参数传递到函数中。
说明:不允许修改给定的链表。
二、题目解析
1、通过快慢指针的方式,在环中寻找它们的第一次相遇的节点位置
2、当快慢指针相遇的时候:
x 代表从头节点到环形入口节点的节点数(不包含头节点)
y 代表从环形入口到第一次相遇节点的节点数(不包含环形入口节点)
z 代表从第一次相遇节点到环形入口的节点数(不包含第一次相遇节点)
此时,快指针走了 x + y + n (y + z),其中,x + y 表示快指针第一次到达相遇节点,n 代表快指针在环里面绕了多少圈。
而慢指针走了 x + y 步。
那么就出现了一个等式 x + y = [x + y + n (y + z)] / 2
,即x = n(y + z)- y
。
n(y + z)- y 代表的含义是一个指针从相遇节点开始出发,走了 n 圈之后回到原来的出发位置,往后退 y 步。
由于 x 代表从头节点到环形入口节点的节点数,并且x = n(y + z)- y
,所以n(y + z)- y 代表的含义就是一个指针从相遇节点开始出发,走了 n 圈之后回到原来的出发位置,往后退 y 步来到了环的入口位置。
那么,我们就可以设置两个指针,一个从链表的头节点开始出发,一个指针从相遇节点开始出发,当它们相遇的时候,代表着环的入口节点找到了。
补充:
- 1、当 slow = 1 , fast = 2 ,为什么 fast 和 slow 一定会相遇?
- 2、当 slow = 1 , fast = 2 ,fast 和 slow 相遇时,slow 指针是否绕环超过一圈?
- 3、slow 和 fast 的移动步数有什么规则?
- 4、能否设置为 slow 每次移动 1 步,fast 每次移动 3、4、5…步?
- 5、为什么设置 slow = 1 , fast = 2 ?
- 6、为什么得出相反的结论?
为了方便大家理解与表达,所以回答尽可能的采取口语化的表达方式,面试的时候你直接拿去用就行。
1、当 slow = 1 , fast = 2 ,为什么 fast 和 slow 一定会相遇?
首先,我们从现实角度去思考。
一个 400 米的圆形跑道上,有跑的慢的人、有跑的快的人,只要给予一定的时间,快的肯定会追上慢的,触发相遇。
环形链表在这个的基础上增加了一条限制:跑道并非连续,而是有一个个的节点组成的。
需要注意,如果两者没有在节点相遇,而是在节点与节点之间的位置相遇,那并非相遇只是相交。
1、假设,fast 在 slow 后方一个节点的位置,那么它们都跳一次之后,fast 和 slow 相遇了。
2、假设,fast 在 slow 后方两个节点的位置,那么它们都跳一次之后,fast 和 slow 的距离缩短为 1,变成了上述假设 1 的问题,可以相遇。
3、假设,fast 在 slow 后方 N 个节点的位置,那么它们都跳一次之后,fast 和 slow 的距离缩短为 N – 1,每条一次,都可以缩短一个单位,不断缩短,最终变成上述的假设 1。
所以,fast 和 slow 一定会相遇。
2、当 slow = 1 , fast = 2 ,fast 和 slow 相遇时,slow 指针是否绕环超过一圈?
从 slow 进入环之后开始统计,fast 与 slow 相距最远的距离是 fast 在 slow 前方一个节点的位置。
此时,假设一下,fast 与 slow 同时在节点 2 开始出发,相当于两者相距一个环的距离。
当 slow 跑完一圈来到起始位置节点 2 时,由于 fast 速度是 slow 的两倍,那么 fast 必然跑了两圈也来到起始位置节点 2 ,两者相遇。
而此时,fast 在 slow 的前方位置,意味着两者的距离是小于一个完整的环的节点数的,说明 fast 可以更快的追上 slow。
既然 fast 与 slow 相距一个环的距离相遇时,slow 才能跑一圈,那么相距更短的距离,slow 没有跑完一圈,两者相遇了。
3、slow 和 fast 的移动步数有什么规则?
只需要两者的步数不一致就行。
4、能否设置为 slow 每次移动 1 步,fast 每次移动 3、4、5…步?
先说答案:可以!
首先,只要快慢两个指针都进入环中,两者有速度差,快指针就一定能够追上慢指针。
追上可以分为两种情况:
1、恰好追上,即快慢指针在某个位置相遇了
2、快指针超过了慢指针,快指针跑到了慢指针的前面了
所以,我们需要分析的就是第二种情况:跑到前面之后能否多跑几圈之后刚好相遇。
假设环的周长为整数 L,slow 每次走 a 步,fast 每次走 b 步,a ≠ b。
相遇时,两者都走了 t 次。
1、slow 走过的路程:x + y + n(y+z), n 代表 slow 绕了 n 圈
2、fast 走过的路程:x + y + m(y+z),m 代表 fast饶了 m 圈
3、m > n
对于 slow :x + y + n(y+z) = a * t
对于 fast :x + y + m(y+z) = b * t
两者一相减:
(m – n)( y + z ) = ( b – a ) * t
y + z 代表一圈的节点数,y + z = L
(m – n)L = ( b – a ) * t
b – a 为一个正整数,假设为 c 。
t = (m – n)L / c。
其中 L 为常量,m 与 n 都可以随便设置,因此 m – n 的值可以为 1、2、3、。。。,
无论 c 取任何的正整数值,始终可以找到 m 与 n,计算得到一个正整数 t 。
也就是说 c 可以为 1、2、3、4、5。。。
说明 slow 与 fast 的速度差可以为 1、2、3、4、5。。。
由此也证明了 slow 每次走 1 步,fast 每次走 2 步、3 步、4 步。。。都是可以相遇的。
甚至,slow 每次走 2 步,fast 每次 3 步、4 步。。。都是可以相遇的。
只要 a ≠ b,存在步数差。
5、为什么设置 slow = 1 , fast = 2 ?
由于 b – a = (m – n)L / t。
说明速度差 b – a 越小,fast 和 slow 跑的圈数就越小,经历的节点数也就越少,
由此 b – a = 1 是一个最小的答案,即 fast 和 slow 相差一步最合理。
然后,再来看,slow 进环的时候,fast 已经在环里面了,当 slow 来到环入口的时候,代表 fast 已经快跑了一圈。
所以,fast 和 slow 相遇,m 至少为 1。
m 越小,fast 总共走的路程就越小,时间复杂度就越低。
所以,m = 1 时最低的时间复杂度。
所以,fast 跑的越慢,越能在环中少跑几圈等到还在外面直线跑的 slow。
由于 a ≠ b, b – a = 1 ,a = 1,所以 b = 2。
所以,设置 slow 为 1 ,fast 为 2 最合理!
6、为什么得出相反的结论?
关于 fast 与 slow 能否相遇的问题,我在网上看到这样的回答。
仔细看看,是不是很有道理,但得到的结论却和本文问题 4 得出的结论不符。
谁是对的呢?
我们顺着它的假设来模拟一下。
假设环的周长为偶数,也就是六个节点。
并且进入环后 slow = 1 ,fast = 3,slow 与 fast 的距离为奇数。
模拟一下,fast 始终会出现在节点 4 和节点 1 这两个位置,当 slow 重新来到节点 1 的时候,fast 又来到了节点 4,如此反复,两者无法相遇。
这个结论是对的??!!
这种假设根本就不会成立!
即进入环后 slow = 1 ,fast = 3,slow 与 fast 的距离为奇数这种假设无法成立。
在进入环之前,slow 和 fast 有一段公共的直线路需要走。
假设这条直线的长度为 m。
那么 slow 需要跳 m 次才能来到环入口位置节点 1 ,fast 需要跳 m/3 次才能第一次来到环入口位置节点 1,环的节点数是 6 个,fast 跑 2 次可以跑完一圈,假设跑了 n 圈,那么就跑了 2n 次,那么再跑一次就来到了节点 4 。
于是有了等式:m = m / 3 + 2n + 1。
计算一下得 n = ( 2m / 3 – 1 ) / 2。
由于 2m 为偶数,根据数学知识一个能被 3 整除的偶数除以 3 仍为偶数,于是 2m / 3 为偶数,2m / 3 – 1 为奇数, ( 2m / 3 – 1 ) / 2 无法是整数。
所以,找不到这样一个整数 m 和整数 n,使得上面的假设成立。
假设不成立,结论也不成立!
三、参考代码
public class Solution {
public ListNode detectCycle(ListNode head) {
// 1、通过快慢指针的方式,在环中寻找它们的第一次相遇的节点位置
// 2、定义一个慢指针,每次只会向前移动 1 步
ListNode slow = head;
// 3、定义一个快指针,每次只会向前移动 2 步
ListNode fast = head;
// 4、如果链表有环,那么无论怎么移动,fast 指向的节点都是有值的
while (fast != null && fast.next != null) {
// 慢指针每次只会向前移动 1 步
slow = slow.next;
// 快指针每次只会向前移动 2 步
fast = fast.next.next;
// 快慢指针相遇,说明有环
// x 代表从头节点到环形入口节点的节点数(不包含头节点)
// y 代表从环形入口到第一次相遇节点的节点数(不包含环形入口节点)
// z 代表从第一次相遇节点到环形入口的节点数(不包含第一次相遇节点)
// y + z 代表环的节点总数
// 此时,快指针走了 x + y + n (y + z)
// 其中,x + y 表示快指针第一次到达相遇节点,n 代表快指针在环里面绕了多少圈
// 此时,慢指针走了 x + y 步
// 由于快指针每次走 2 步,所以快慢指针第一次相遇的时候出现一个等式
// x + y = [x + y + n (y + z)] / 2
// 即 2 * (x + y) = x + y + n (y + z)
// 即 x + y = n(y + z)
// 即 x = n(y + z)- y
// 我们的目的就是去求 x
// 定义两个指针,一个指向相遇节点,定义为 b,一个指向链表头节点,定义为 a
// b 在环中绕圈圈,走了 n(y + z)步会回到原处,即回到相遇节点处
// 由于 y 代表从环形入口到第一次相遇节点的节点数(不包含环形入口节点)
// 所以 n(y + z) - y 时,b 到达了环形入口节点位置
// 由于 x 代表从头节点到环形入口节点的节点数(不包含头节点)
// 所以 a 走了 x 步时,a 到达了环形入口节点位置
// 当 x = n(y + z)- y 时,找到了环形入口节点位置
// 5、开始寻找环入口
if (slow == fast) {
// 定义两个指针,一个指向相遇节点,定义为 b,一个指向链表头节点,定义为 a
// 一个指向相遇节点,定义为 b
ListNode b = fast;
// 一个指向链表头节点,定义为 a
ListNode a = head;
// 让 a 、b 两个指针向前移动,每次移动一步,直到相遇位置
// 由于有环,必然相遇
// 当 b 走了 n(y + z) - y 时,b 到达了环形入口节点位置
// 当 a 走了 x 步时,a 到达了环形入口节点位置
// a 与 b 相遇
while (a != b) {
// a 指针每次只会向前移动 1 步
a = a.next;
// b 指针每次只会向前移动 1 步
b = b.next;
}
// 6、返回 a 和 b 相遇的节点位置就是环形入口节点位置
return a;
}
}
// 没有环,返回 null
return null;
}
}