剑指offer--链表中环的入口结点

题目描述

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

代码

ListNode* EntryNodeOfLoop(ListNode* pHead) {
		
		
#if 0
	//首先判断这个链表中是否有环
	/*方法一：穷举遍历法
					遍历链表中的每一个结点，对于每个遍历的结点都要从头节点开始遍历，
					看这个结点之前的结点中是否和正在遍历的结点一样
					若一样则说明链表中存在环。
假设从链表头节点到入环点的距离是D，链表的环长是S。那么算法的时间复杂度是0+1+2+3+....+(D+S-1) = (D+S-1)*(D+S)/2 ，
可以简单地理解成 O(N*N)。而此算法没有创建额外存储空间，空间复杂度可以简单地理解成为O(1)。
					*/
		bool flag = false;//链表中是否有环的标志
		ListNode* p;
		p = pHead;
		ListNode* input;//入口结点
		input = NULL;
		//这个链表的头结点中的值是有意义的数值。
		int count = 0;
		int i = 1;//用来记录重新遍历的结点数：从第一个结点开始遍历，遍历到当前结点的前一个结点
		while (p != NULL)
		{
			count++;//计算链表中的结点数：先判断是不是NULL，再加1
			if (count > 1)//从第一个节点之后开始判断前面是否有相同的数值
			{
				ListNode* s;
				s = pHead;//重新从头结点开始遍历判断
				i = 1;
				while (s != NULL && i <=count - 1)
				{			
					if (s==p)//前面存在和当前结点值相同的结点
					{
						flag = true;//存在环
						input = s;//保存入口结点
						break;
					}
					s = s->next;
					i++;
				}
				if(flag)//前面判断存在环
					break;
			}
			p = p->next;//判断下一个结点
		}
		//若其中包含环，请找出该链表的环的入口结点，否则，输出null
			if (flag)
		{
			return input;

		}
		else
			return NULL;
#endif
#if 0
			//方法二：哈希表缓存
 /*首先创建一个以节点ID为键的HashSet集合，用来存储曾经遍历过的节点。然后同样是从头节点开始，
 依次遍历单链表的每一个节点。每遍历到一个新节点，
 就用新节点和HashSet集合当中存储的节点作比较，
 如果发现HashSet当中存在相同节点ID，则说明链表有环，
 如果HashSet当中不存在相同的节点ID，就把这个新节点ID存入HashSet，之后进入下一节点，继续重复刚才的操作。
  这个方法在流程上和方法一类似，本质的区别是使用了HashSet作为额外的缓存。
   假设从链表头节点到入环点的距离是D，链表的环长是S。而每一次HashSet查找元素的时间复杂度是O(1),
   所以总体的时间复杂度是1*(D+S)=D+S，可以简单理解为O(N)。
   而算法的空间复杂度还是D+S-1，可以简单地理解成O(N)。

		 */		 	 
	
			unordered_set<ListNode* > myset;//定义一个容器：里面存放ListNode类型的结点
		
			ListNode* p = pHead;
			while (p != NULL)
			{
				
				if (myset.empty())
					myset.insert(p);
				else
				{//判断当前结点之前是否有和这个相同的结点					
					if (myset.find(p) == myset.end())//没有找到相同的结点
					{
						myset.insert(p);
					}			
					else
					{					
						return p;//找到了相同的结点
					}					

				}
				p = p->next;
			}
			return NULL;

#endif
#if  1
/*方法三：快慢指针
定义两个指针：快指针每次移动两个节点，慢指针每次移动一个节点，如果链表中有环，则两个指针会相遇:指的是两个结点相同
若没有环，最后一个结点肯定是指向NULL


首先创建两个指针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，
此时两指针指向同一节点，判断出链表有环。
此方法也可以用一个更生动的例子来形容：在一个环形跑道上，两个运动员在同一地点起跑，一个运动员速度快，
一个运动员速度慢。当两人跑了一段时间，速度快的运动员必然会从速度慢的运动员身后再次追上并超过，原因很简单，因为跑道是环形的。
时间复杂度为O（N），除了两个指针以外，没有使用任何额外存储空间，所以空间复杂度是O（1）。

*/
			bool flag = false;
			ListNode* slow, * fast;
			
			slow = pHead;
			fast = pHead;
			while (fast != NULL&& fast->next!=NULL&&fast ->next->next!= NULL)
			{
				slow = slow->next;
				fast = fast->next->next;
				if (fast == slow)
				{
					flag = true;
					break;
				}
				
			}
			if (flag)//存在环
			{
				//计算环的长度：从快慢指针相遇的结点开始计数再走一圈，再次走到相遇结点时，得到环的长度
				//int length = 0;//环的长度
				//ListNode* s= slow->next;//相遇结点后的第一个结点
				//while (s != fast)
				//{
				//	length++;
				//	s = s->next;		
				//}
				//得到环的入口结点（知道环的长度的情况下）
				/*定义两个指针：head1、head2同时指向头结点，让head1先走环的长度的步数，head2不动；
				再让head1和head2同时出发，当head1和head2相遇的时候，这个点就是环的入口结点
				（因为head1和head2始终相差一个环的距离）。
				*/
				//得到环的入口结点（不知道环的长度的情况下）
				/*当快慢指针相遇的时候，fast-slow=n*cir,cir表示环的长度，n表示fast在环中走的圈数，
				又因为fast=2*slow,所以slow=n*cir。
				再建立一个新指针new_case从起点开始按照和slow一样的速度走（slow和new同时走），
				new_case和slow会在环的入口结点相遇，因为：假设new_case走到环的入口结点是m，则slow也总共走了m+n*cir，			
				*/
				ListNode* new_case = pHead;
				while (new_case != NULL && slow!=NULL)
				{
					if (new_case == slow)
					{
						return slow;//相遇的点就是入口结点
					}
					else
					{
						new_case = new_case->next;
						slow = slow->next;
					}
				}



			}
			else
				return NULL;//不存在环
#endif


	}