一,判断链表是否存在环:
1)题目链接:
力扣https://leetcode.cn/problems/linked-list-cycle/
难度简单1498
给你一个链表的头节点
head
,判断链表中是否有环。如果链表中有某个节点,可以通过连续跟踪
next
指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。注意:pos
不作为参数进行传递 。仅仅是为了标识链表的实际情况。如果链表中存在环 ,则返回
true
。 否则,返回false
。示例 1:
输入:head = [3,2,0,-4], pos = 1 输出:true 解释:链表中有一个环,其尾部连接到第二个节点。示例 2:
输入:head = [1,2], pos = 0 输出:true 解释:链表中有一个环,其尾部连接到第一个节点。示例 3:
输入:head = [1], pos = -1 输出:false 解释:链表中没有环。提示:
- 链表中节点的数目范围是
[0, 104]
-105 <= Node.val <= 105
pos
为-1
或者链表中的一个 有效索引 。进阶:你能用
O(1)
(即,常量)内存解决此问题吗?
·
2)思路+代码:
2.1)hash表判断节点重复:
这个很简单,就是利用一个HashMap或者hashSet,遍历链表,不断将链表中的Node节点加入到hash表中,并判断hash表中是否存在重复的Node节点;
如果是一个环,一定会进行重复遍历,则hash表便会判断出来;
看代码:
/**
* 利用hash表判断重复
* @param head
* @return
*/
public boolean hasCycle2(ListNode head) {
Set<ListNode> hashSet = new HashSet<>();
while (head != null) {
boolean add = hashSet.add(head);
if (add) {
head = head.next;
}else{
return true;
}
}
return false;
}
·
2.2)双指针法-快慢指针:(重点)
/**
* 快慢指针的方式
* 1,双指针法,一个快指针,一个慢指针,
* 2,初始化,都指向头结点;
* 3,快指针一次走两步,慢指针一次走一步;
* 4.1,如果存在环,那么快慢指针一定会在环里边相遇!
* 4.2,如果不存在环,那么快指针会首先到达链表末尾,即ListNode.next==null;
* @param head
* @return
*/
public boolean hasCycle1(ListNode head) {
ListNode fast = head; //快指针
ListNode slow=head; //慢指针
while (fast != null) {
try {
fast = fast.next.next; //快指针一次走两步
slow = slow.next; //慢指针一次走一步;
if (Objects.equals(fast, slow)) {
return true; //快慢指针相遇,说明是个环;
}
} catch (NullPointerException e) {
//因为快指针一次走两步,有可能会出现空指针异常,此时也说明了不是环,则直接返回false;
return false;
}
}
return false;
}
·
二,已知链表存在环,返回这个环的起始位置:
1)题目链接:
力扣https://leetcode.cn/problems/c32eOV/
难度中等57
给定一个链表,返回链表开始入环的第一个节点。 从链表的头节点开始沿着
next
指针进入环的第一个节点为环的入口节点。如果链表无环,则返回null
。为了表示给定链表中的环,我们使用整数
pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果pos
是-1
,则在该链表中没有环。注意,pos
仅仅是用于标识环的情况,并不会作为参数传递到函数中。说明:不允许修改给定的链表。
示例 1:
输入:head = [3,2,0,-4], pos = 1 输出:返回索引为 1 的链表节点 解释:链表中有一个环,其尾部连接到第二个节点。示例 2:
输入:head = [1,2], pos = 0 输出:返回索引为 0 的链表节点 解释:链表中有一个环,其尾部连接到第一个节点。示例 3:
输入:head = [1], pos = -1 输出:返回 null 解释:链表中没有环。提示:
- 链表中节点的数目范围在范围
[0, 104]
内-105 <= Node.val <= 105
pos
的值为-1
或者链表中的一个有效索引进阶:是否可以使用
O(1)
空间解决此题?
·
2)思想:
1,我们设环的长度为l;
2,慢指针走了多远,我们设它走了k;
3,快指针走了多远,因为慢指针一次走一步,快指针一次走两步,所以快指针走了2k;
·
结论1,那快指针比慢指针多了哪些路径呢?
首先,非环部分,快慢指针都走过了;
所以,快指针多走了的路径就是环的部分,即多个环的长度,即2k-k=x*l;
结论:k=x*l;
·
结论2,非环部分的长度?
我们设相遇点与环起点的距离为m,又因为慢指针走了k,所以非环部分的长度为k-m;
如图所示:
·
结论3,相遇点到环起点的长度?
我们知道环的长度为l,所以相遇点第1次到环起点的长度为1*l-m,
相遇点第2次到环起点的长度为2*l-m,
相遇点第x次到环起点的长度为:x*l-m;
·
结论4, 非环部分的长度 等于 相遇点第x次到环起点的长度;
结论2中,我们知道非环部分的长度为:k-m;
又结论1中我们知道,k=x*l;
所以非环部分的长度为:x*l-m;
结论3中我们知道,相遇点第x次到环起点的长度为:x*l-m;
结论:非环部分的长度 == 相遇点第x次到环起点的长度;
也就是说,如果我们有两个一样的指针a和b,a指针从链表head节点出发,b指针从相遇点出发,那么当a指针到达环起点的时候,b指针可能已经转了多圈,但是总之,此时的b指针也一定在环起点的位置。
·
3)代码:
3.1)解题步骤:
1,前期跟判断链表存在环是一样的,一个快指针,一个慢指针,直到快慢指针重合;
2,快慢指针重合的位置,即相遇点,此时新建两个一样的指针,a指针从head节点出发,b指针从相遇点出发;
3,当a指针和b指针重合的时候,该位置即为环起点的位置。
·
3.2)看代码:
/**
* 解题步骤:
* 1,前期跟判断链表存在环是一样的,一个快指针,一个慢指针,直到快慢指针重合;
* 2,快慢指针重合的位置,即相遇点,此时新建两个一样的指针,a指针从head节点出发,b指针从相遇点出发;
* 3,当a指针和b指针重合的时候,该位置即为环起点的位置。
*
* @param head
* @return
*/
public static ListNode detectCycle(ListNode head) {
//base case特殊情况:
if (head == null) {
return null;
} else if (head.next == null) {
return null;
}
try {
//声明并初始化快慢指针:
ListNode fast = head;
ListNode slow = head;
while (true) {
fast = fast.next.next; //快指针一次走两步
slow = slow.next; //慢指针一次走一步
//当快慢指针重合的时候,跳出循环:
if (fast == slow) {
break;
}
}
//当快慢指针重合的时候,跳出循环,此时重合为位置为相遇点:
ListNode xiangyuNode = fast;
//新建两个一样的指针,a指针从head出发,b指针从相遇点出发:
ListNode a = head;
ListNode b = xiangyuNode;
while (true) {
//当a指针和b指针重合的时候,该位置即为环起点的位置。
if (a == b) {
break;
}
a = a.next;
b = b.next;
}
ListNode huanStartNode = a;
return huanStartNode;
} catch (NullPointerException e) {
return null;
}
}