程序员面试问题（六）

算法部分(3)

3,判断一个单链表是否存在环。

思路：1.最朴素的想法，遍历链表，把每一个节点地址储存起来，每遇到一个节点，先看这个节点是否已经访问，若访问过，则存在环。为了查找方便快速，可以使用哈希存储，

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

2.追赶法。采用两个指针fast与slow，fast每次前进两个节点，slow每次前进一个节点，如果有环的话，fast会与slow相遇。下面说明为什么相遇，首先，若是有环，两个指针最终肯定都在换内转圈。在圈内如图：

假设环内有M个节点，目前slow与fast顺时针相距L个节点，逆时针相距M-L个节点，当前进时，因为fast比slow多前进一步，所以逆时针相距增加1，顺时针相距减少1，如此，经过M-L步，两个指针相遇。进入环之后，因为能在M-L ＜　M步内相遇，所以判断时间复杂度为Ｏ（ｎ）。

灼爷的代码：

#include <stdio.h>
#include <stdlib.h>
struct Node{
	int element;
	struct Node* next;
};
typedef struct Node *PtrToNode;
typedef	PtrToNode Position;
typedef PtrToNode List;
void MakeEmpty(List l)
{
	l->next =NULL;
}
// insert after the head
List Insert(int x,List l)
{
	Position tmpCell;
	tmpCell =(Position)malloc(sizeof(struct Node));
	if(tmpCell ==NULL)
		{
			printf("out of space ");
			return NULL;
		}
		else
		{
		tmpCell->element = x;
		tmpCell->next =l->next;
		l->next =tmpCell;
		return l;
	}

}
void print(List l)
{
	Position k =l->next;
	while(k)
	{
		printf("%d\t",k->element);
		k =k->next;
	}
}
List reserve(List l)
{
	if(!l->next)
	{
		printf("an empty list");
		return NULL;
	}
	else
	{
		Position preNode,curNode,nextNode;
		preNode =NULL;
		curNode =l->next;
		nextNode =curNode->next;
		while(nextNode !=NULL)
		{
			curNode->next =preNode;
			preNode =curNode;
			curNode =nextNode;
			nextNode =nextNode->next;
		}
		curNode->next =preNode;
		l->next =curNode;
		return l;
	}
}
Position Find(int x,List l)
{
	Position p;
	p =l->next;
	while(p)
	{
		if(p->element ==x)
			break;
		p =p->next;
	}
	return p;
}
Position findLast(List l)
{
	Position p;
	p =l;
	while(p->next)
	{
		p =p->next;
	}
	return p;
}
//将可用的链表变成坏链表 ，使尾指针指向某中间节点
void MakeLoop(int x,List l)
{
	Position p =findLast(l);
	p ->next =Find(x,l);
}


Position get2Next(Position p,List l)
{
	p =p->next;
	if(p)
		{
			p =p->next;
			return p;
		}
	else
		return NULL;
}
int IsLoop1(List l)
{
	int flag =0;
	Position slow,fast,t;
	slow =l;
	fast =l;
	while((fast->next) && (fast->next->next))
	{

		while(fast->next)
		{
			fast =get2Next(fast,l);
			slow =slow->next;
			if(fast ==slow)
			{
				flag =1;
				break;
			}
		}
		if(flag)
			break;
	}
	return flag;
}
int main()
{
	List l =(List)malloc(sizeof(struct Node));
	MakeEmpty(l);
	for(int i =10;i>0;i--)
		Insert(i,l);
	print (l);
	MakeLoop(6,l);
	//print(l);
	printf("\n");
	//IsLoop1(l);
	int k =IsLoop1(l);
	printf("%d",k);

	return 0;
}

　

另：如果计算环的长度以及环的入口点，不妨如下操作：

1.环的长度：第一次相遇后继续移动指针，等待下一次相遇，移动次数就是环的长度(因为相遇时逆时针相距M，要M步才能再次相遇)

2.入口点：设指针a，b分别从链表头和第一次相遇点开始遍历，相遇点就是入口.

证明：

设slow走了s步，则fast为2s步。设第一次相遇时fast在环内转了n圈则有：

2s = s ＋nM 即 s = nM

设入口点到链表头距离为x，入口点到相遇点为y,链表长 L

则 s = x + y = nM = (n-1)M +　M = (n-1)M + L -x

所以,x = (n-1)M  +（L-x-y）其中L-x-y 是从相遇点到入口处的逆时针距离，证毕。

3.链表长度：fast slow第一次相遇步数+环的长度