环形链表的判断方法及实现

在公众号看到一篇文章，如何判断链表有环？
环是个什么东西，查了下，原来就是链表中有元素指向之前有过的元素。那么如何判断呢，查了下相关资料，将环形链表的判断方法做了一个梳理，并用Python和C++实现了一下，记录如下。
不过由于数据结构不扎实，先用数组这种顺序存储来作为数据的数据结构吧……………好low!!!

题目

如何判断链表有环？
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

示例 1：

输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：

输入：head = [1,2], pos = 0 输出：true 解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：

输入：head = [1], pos = -1 输出：false 解释：链表中没有环。

更通俗的说，比如head=[3,2,0,-4,2]，我们发现最后一个节点是指向第二个节点的（节点编号从1开始）。那么有几种判断方法呢？

方法1：普通查找法

分析

首先从头节点开始，依次遍历单链表的每一个节点。每遍历到一个新节点，就从头节点重新遍历新节点之前的所有节点，用新节点ID和此节点之前所有节点ID依次作比较。如果发现新节点之前的所有节点当中存在相同节点ID，则说明该节点被遍历过两次，链表有环；如果之前的所有节点当中不存在相同的节点，就继续遍历下一个新节点，继续重复刚才的操作。

例如这样的链表：A->B->C->D->B->C->D， 当遍历到节点D的时候，我们需要比较的是之前的节点A、B、C，不存在相同节点。这时候要遍历的下一个新节点是B，B之前的节点A、B、C、D中恰好也存在B，因此B出现了两次，判断出链表有环。

假设从链表头节点到入环点的距离是D，链表的环长是S。那么算法的时间复杂度是0+1+2+3+…+(D+S-1) = (D+S-1)*(D+S)/2 ， 可以简单地理解成 O(N_*N)。而此算法没有创建额外存储空间，空间复杂度可以简单地理解成为O(1)。

这种方法最容易想到，当然效率也最低。往往最容易想到或者做到的事情，价值最低，这可以作为一个普适的真理。

实现

C++

#include <iostream>
#include <string>
using namespace std;

int main(){
	int list[]={3,2,0,-4,2},flag=0;
	for(int i=1;i<sizeof(list);i++){
		for(int j=0;j<i;j++){
			if(list[i]==list[j]){
				printf("环入口：%d",j);
				flag=1;
				break;
			}
		}
		if(flag==1)	break;
	}
	return 0;
} 
/* 
环入口：1
--------------------------------
Process exited after 0.3827 seconds with return value 0
请按任意键继续. . .
*/

Python

list=[3,4,2,0,-4,2]
flag=0
for i in range(1,len(list)+1):
	for j in range(0,i):
		if list[i]==list[j]:
			print("环入口为：{}".format(j))
			flag=1
			break
	if flag==1:
		break

方法2：Hash列表

分析

网上我看到以ID为键的哈希，这种方法会导致hash的数量是线性增长的。为什么不以链表的值为hash的键呢？然后遍历。如果发现新存入hash的value为0，则继续遍历；否则，说明之前已经存过hash的键，也就是链表中已经存在当下节点的值，即存在环。

从这个角度考虑环，实际上就是判断链表中有无相同的元素。这是一个经典的问题，比较好的方法就是使用hash列表。hash方法的时间复杂度是O(1)*n=O(n)，这个时间复杂度已经是最优。最坏情况下空间复杂度是O(n)。空间复杂度与具体问题有关系，比如链表元素是纯一个数字情况下的空间复杂度是O(10)，纯字母的空间复杂度是O(52)。

键值对的方法是数学中函数思想的集中体现

实现

C++

#include <iostream>
#include <string>
#include <map>
using namespace std;

int main(){
	int list[]={3,2,0,-4,2},flag=0;
	map<int,int> map;
	for(int i=1;i<sizeof(list);i++){
		if(map[list[i]]){
			printf("环出口为：%d",i);
			break;
		}	
		else map[list[i]]++;
	}
	return 0;
} 
/* 
环出口为：4
--------------------------------
Process exited after 0.3827 seconds with return value 0
请按任意键继续. . .
*/

python

list=[3,2,0,-4,2]
cnt={}
for i in range(len(list)):
	cnt[list[i]]=cnt.get(list[i],0)+1
	if cnt[list[i]]>1:
		print("环出口为：{}".format(list[i]))
		break;
#环出口为：2
# [Finished in 0.1s]

补充

当我写完这种方法的C++实现时，我意识到了网上使用节点ID作为hash的键的意义所在，意义就是可以记录环的入口。而只使用以节点的值为hash列表的键时，只能记录环的出口。所以printf的时候我写下了“环出口为：”

hash的意义在于减少了一层for循环，所以可以大大降低时间复杂度。

方法3：快慢指针

分析

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

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

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

假设从链表头节点到入环点的距离是D，链表的环长是S。那么循环会进行S次（为什么是S次，有心的同学可以自己揣摩下），可以简单理解为O（N）。除了两个指针以外，没有使用任何额外存储空间，所以空间复杂度是O（1）。

这是快慢指针的经典应用。
设置两个指针，一个每次走一步的慢指针和一个每次走两步的快指针。
如果不含有环，跑得快的那个指针最终会遇到 null，说明链表不含环
如果含有环，快指针会超慢指针一圈，和慢指针相遇，说明链表含有环。

实现

C++

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