JAVA找环节点_判断单链表中是否有环，找到环的入口节点

方法一：类似冒泡算法查找匹配，时间复杂度O(n^2)

方法二：hashset

方法三：这里主要讲的这个，比较新奇，时间复杂度O(n)

首先创建两个指针1和2(在java里就是两个对象引用)，同时指向这个链表的头节点。然后开始一个大循环，在循环体中，让指针1每次向下移动一个节点，让指针2每次向下移动两个节点，然后比较两个指针指向的节点是否相同。如果相同，则判断出链表有环，如果不同，则继续下一次循环。

例如链表A->B->C->D->B->C->D，两个指针最初都指向节点A，进入第一轮循环，指针1移动到了节点B，指针2移动到了C。第二轮循环，指针1移动到了节点C，指针2移动到了节点B。第三轮循环，指针1移动到了节点D，指针2移动到了节点D，此时两指针指向同一节点，判断出链表有环。

此方法也可以用一个更生动的例子来形容：在一个环形跑道上，两个运动员在同一地点起跑，一个运动员速度快，一个运动员速度慢。当两人跑了一段时间，速度快的运动员必然会从速度慢的运动员身后再次追上并超过，原因很简单，因为跑道是环形的。

看了上门一堆，看懂了，但是还是不知道为什么，下面来具体看看：

假设，整个链表长为L,链表环的长度为n,已逆时针方式在环上运动

链表头到环节点的长度为a ---->L=a+n;

1.此图表示slow运动到了t，fast运动到m1时，由于slow的速度是fast的一半，所以2a=n*m+b+a;-->a=n*m+b;(m为fast在此时已经链表环中运行次数，m>=0，且m为整数)

a=n*m+b;

L-n=n*m+b;

b=L-n-n*m;

b=L-(m+1)*n;

2.当slow,fast相遇在节点m2，m2到t的距离为b2

假设slow运行距离为s,

s=a+n-b2;

2s=s+n*m;(m为fast在此时已经链表环中运行次数，m>=1，且m为整数)

所以s=n*m,所以n*m=a+n-b2;

代入L=a+n;

n*m=L-n+n-b2;

b2=L-n*m;

所以图片中的b,b2可能相等，也可能相差m个链表环。

code：

packagecom.qhong.dataStructures.demo1;importjava.util.HashMap;public classLinkLoop {//方法2：将每次走过的节点保存到hash表中，如果节点在hash表中，则表示存在环

public static booleanhasLoop2(Node n){

Node temp1=n;

HashMap ns = new HashMap();while(n!=null){if(ns.get(temp1)!=null)return true;elsens.put(temp1, temp1);

temp1=temp1.next;if(temp1 == null)return false;

}return true;

}//找出环的连接点

public staticNode EntryNodeOfLoop(Node h){if(h == null || h.next == null)return null;

Node slow=h;

Node fast=h;while(fast != null && fast.next != null){

slow=slow.next;

fast=fast.next.next;

System.out.println("temp1："+slow.val+",temp2:"+fast.val);//交接就说明有链表环

if(slow ==fast){

System.out.println("链表存在环！");int count = 0;

Node p=h;

Node q=slow;//相当于让q指向了m1

while(p !=q){

count++;

p=p.next;

q=q.next;

System.out.println("p："+p.val+",q:"+q.val);

}if(p ==q) {

System.out.println("环的长度：" +count);

System.out.println("环的入口节点为：" +q.val);returnq;

}

}

}return null;

}public static voidmain(String[] args) {

Node n1= new Node(1);

Node n2= new Node(2);

Node n3= new Node(3);

Node n4= new Node(4);

Node n5= new Node(5);

Node n6= new Node(6);

Node n7= new Node(7);

Node n8= new Node(8);

n1.next=n2;

n2.next=n3;

n3.next=n4;

n4.next=n5;

n5.next= n6; //构造一个带环的链表,去除此句表示不带环

n6.next =n7;

n7.next=n8;

n8.next=n5;//System.out.println(hasLoop2(n1));

System.out.println(EntryNodeOfLoop(n1).val);

}

}classNode{publicNode(Integer num){this.val=num;

}publicNode next;public intval;

}

Output:

temp1：2,temp2:3temp1：3,temp2:5temp1：4,temp2:7temp1：5,temp2:5链表存在环！

p：2,q:6p：3,q:7p：4,q:8p：5,q:5环的长度：4环的入口节点为：5

5