单链表形成环 java_[数据结构与算法]07 关于单链表环的操作( Java 版)

单链表经典操作,第一个是单链表反转,在这篇文章中已经写过了:[数据结构与算法]04 Link List (链表)及单链表反转实现,第二个是判断链表中是否有环,也就是今天这篇文章想要说的.

判断链表是否有环

如图,我们能够清楚看到,这个链表是有环的.

咱们一起来分析一下

判断链表中是否有环,可以从头结点开始,依次遍历单链表中的每一个节点.每遍历一个节点,就和前面的所有节点作比较,如果发现新节点和之前的某个节点相同,则说明此节点被遍历过两次,说明链表有环,反之就是没有.

但是仔细看一下这种方法,你会发现这种方法很耗时耗力,因为每遍历一个节点,都要把它和前面所有的节点都比较一遍.

还有一个很巧妙的方法,就是使用两个指针.

使用两个指针,一个快指针,一个慢指针.

快指针每次走 2 步,慢指针每次走 1 步.

如果链表中没有环,则快指针会先指向 null

如果链表中有环,则快慢指针一定会相遇

基于这个思路,可以使用代码实现:

/**

* 判断链表是否有环

* @author 郑璐璐

* @datetime 2019-12-28 09:44:41

*/

public class IsHasLoop {

public static class Node{

private int data;

private Node next;

public Node(int data,Node next){

this.data=data;

this.next=next;

}

public int getData(){

return data;

}

}

public static void main(String[] args){

// 初始化单链表

Node node5=new Node(5,null);

Node node4=new Node(4,node5);

Node node3=new Node(3,node4);

Node node2=new Node(2,node3);

Node node1=new Node(1,node2);

// 让 node5 的指针指向 node1 形成一个环

node5.next=node1;

boolean flag=isHasLoop(node1);

System.out.println(flag);

}

public static boolean isHasLoop(Node list){

if (list == null){

return false;

}

Node slow=list;

Node fast=list;

while (fast.next != null && fast.next.next != null){

// 慢指针走一步,快指针走两步

slow=slow.next;

fast=fast.next.next;

// 如果快慢指针相遇,则说明链表中有环

if (slow==fast){

return true;

}

}

// 反之链表中没有环

return false;

}

}

求环长

现在已经将链表中是否有环判断出来了,接下来扩展一下,求环长.

先理一下整体思路:

当快慢指针第一次相遇时,我们可以记录下此时的位置.

接下来让慢指针继续走,每次走 1 步,直到走到第一次相遇的地方,此时慢指针走过的长度即为环长

基于这样的思路,就可以将代码实现:

public static int getLength(Node list){

// 定义环长初始值为 0

int loopLength=0;

Node slow=list;

Node fast=list;

while (fast != null && fast.next != null) {

// 慢指针走一步,快指针走两步

slow=slow.next;

fast=fast.next.next;

// 第一次相遇时跳出循环

if (slow == fast) break;

}

// 如果 fast next 指针首先指向 null 指针,说明该链表没有环,则环长为 0

if(fast.next == null || fast.next.next == null){

return 0;

}

// 如果有环,使用临时变量保存当前的链表

Node temp = slow;

// 让慢指针一直走,直到走到原来位置

do{

slow = slow.next;

loopLength++;

} while(slow != temp);

return loopLength;

}

求入环点

求入口节点有点儿绕,咱们先来上一张图:

如上图,假设:

入环点距离头结点距离为 D

入环点与首次相遇点较短的距离为 S1

入环点与首次相遇点较长的距离为 S2

当两个指针首次相遇时,慢指针一次只走 1 步,则它所走的距离为: D+S1

快指针每次走 2 步,多走了 n(n>=1) 圈,则它所走的距离为: D+S1+n(S1+S2)

快指针速度为慢指针的 2 倍,则: 2(D+S1)=D+S1+n(S1+S2)

上面等式,整理可得: D=(n-1)(S1+S2)+S2

如果让 (n-1)(S1+S2) 为 0 ,是不是 D 和 S2 就相等了?也就是说,当两个指针第一次相遇时,只要把其中一个指针放回到头结点位置,另外一个指针保持在首次相遇点,接下来两个指针每次都向前走 1 步,接下来这两个指针相遇时,就是要求的入环点.

有点儿像做数学题的感觉~

基于这样的思路,可以将代码实现:

public static Node entryNodeOfLoop(Node list){

Node slow=list;

Node fast=list;

while(fast.next != null && fast.next.next != null){

// 慢指针走一步,快指针走两步

slow=slow.next;

fast=fast.next.next;

// 第一次相遇时跳出循环

if (slow == fast) break;

}

// 如果 fast next 指针首先指向 null 指针,说明该链表没有环,则入环点为 null

if (fast.next == null || fast.next.next == null){

return null;

}

// 第一次相遇之后,让一个指针指向头结点,另外一个指针在相遇位置

// 两个指针每次走 1 步,相遇为止,此时相遇节点即为入环点

Node head=list; // 头结点

Node entryNode=slow; // 相遇节点

while (entryNode != head){

entryNode=entryNode.next;

head=head.next;

}

return entryNode;

}

关于链表的一些操作差不多就是这些了.

其实仔细观察能够看到,不管是求环长,还是找到入环点,最关键的是找到第一次相遇时所在的位置,基于这一点,接下来的问题就比较容易解决.

参考:

漫画算法:小灰的算法之旅

以上,感谢您的阅读~