C# 判断一个单链表是否有环及环长和环的入口点

1.为什么写这个随笔？

前几天参加一个电面，被问到这个问题，想总结一下。

2.为什么标题强调C#？

想在网上看看代码，却没找到C#版的，于是自己用C#实现一下。

一、解决问题的思路

1.一种比较耗空间的做法是，从头开始遍历链表，把每次访问到的结点存入一个集合（hashset）或字典（dictionary），如果发现某个结点已经被访问过了，就表示这个链表存在环，并且这个结点就是环的入口点。

空间复杂度为O(n)，时间复杂度为O(n)

2.追赶法：使用两个slow, fast指针从头开始扫描链表。指针slow 每次走1步，指针fast每次走2步。如果存在环，则指针slow、fast会相遇；如果不存在环，指针fast遇到NULL退出。

空间复杂度为O(1)，时间复杂度为O(n)

仅仅考虑代码实现方面第一种方法相对简单，所以下面用第二种方法来实现。

二、解析（追击相遇）

给出一个存在环的单链表：1,2,3,4,5,3,4,5...

用图表示出来：

然后按照追赶法的定义一步一步走：

从上图可以看出第四次和第七次快慢指针在节点4处相遇，7-4=3，正好是环的长度；

求出环的长度后，我们便可以求出入口点：

链表总长=5；

头结点到入口点的距离=链表总长-环长；即=5-3=2；

然后从头结点开始向下遍历，得到入口点3；

三、代码

1.单链表节点

 //单链表节点
 class LinkNode<T>
     {
         public LinkNode<T> Next
         { get; set; }
         public T Data
         { get; set; }
         public LinkNode()
         {
             Data = default(T);
             Next = null;
         }
         public LinkNode(T val)
         {
             Data = val;
             Next = null;
         }
         public LinkNode(T val,LinkNode<T> node)
         {
             Data = val;
             Next = node;
         }
     }

2.单链表

     class DLinkedList<T>
     {
         public LinkNode<T> Head
         { get; set; }
         public int Length
         { get; set; }
         public DLinkedList()
         {
             Length = ;
             Head = null;
         }
         public void Add(LinkNode<T> node)//插入节点
         {
             if (IsEmpty())
             {
                 Head = node;
                 Length++;
                 return;
             }
             else
             {
                 LinkNode<T> currentNode = Head;
                 while (currentNode.Next != null)
                 {
                     currentNode = currentNode.Next;
                 }
                 currentNode.Next = node;
                 Length++;
             }
         }
         public void Display()//显示链表
         {
             LinkNode<T> currentNode = Head;
             while (currentNode != null)
             {
                 Console.WriteLine(currentNode.Data);
                 currentNode = currentNode.Next;
             }
         }
         public int GetLength()//获取链表长度
         {
             return Length;
         }
         public bool IsEmpty()//判空
         {
             return Head == null ? true : false;
         }
         public bool HasCircle()//判断是否有环
         {
             LinkNode<T> slowNode = Head;
             LinkNode<T> fastNode = Head;//定义快慢节点，开始指向头结点
             bool result = false;
             int count = ;
             int step = ;
             while (slowNode.Next != null && fastNode.Next.Next != null)
             {
                 try
                 {
                     slowNode = slowNode.Next;//慢节点指向下一个
                     fastNode = fastNode.Next.Next;//快节点指向下一个节点的下一个节点
                 }
                 catch (NullReferenceException)
                 {
                     result = false;
                     break;
                 }
                 if (slowNode == fastNode && slowNode != Head && slowNode != null)
                 {
                     result = true;
                     Console.WriteLine($"The currentNode's Data is {slowNode.Data}");
                     count++;
                 }
                 if (count == )//第一次相遇
                     step++;//计步，获取环长
                 if (count == )//第二次相遇
                 {
                     Console.WriteLine($"Circle's length is {step}");
                     break;
                 }
             }
             GetPoint(step);
             return result;
         }
         public LinkNode<T> GetPoint(int circleLength)//获取相交点
         {
             int lineLength = Length -circleLength;
             int num = ;
             LinkNode<T> currentNode = Head;
             while(currentNode.Next!=null)
             {
                 currentNode = currentNode.Next;
                 num++;
                 if(num==lineLength)
                 {
                     break;
                 }
             }
             Console.WriteLine($"The meet node's Data is {currentNode.Data}");
             return currentNode;
         }
     }

3.测试

 class Program
     {
         static void Main(string[] args)
         {
             DLinkedList<int> list = new DLinkedList<int>();
             LinkNode<int> tmp=null;
             for(int i =;i<=;i++)
             {
                 LinkNode<int> node = new LinkNode<int>(i);
                 if (i == )
                     tmp = node;
                 list.Add(node);
             }
             list.Add(tmp);
             Console.WriteLine(list.HasCircle());
             Console.ReadKey();
         }
     }

测试结果如图：