题目为:对于普通的单向链表,如果实现确定其内部有一个环,如何确定何处出现环路的?单向链表每个节点中只有data和next两个字段。
(单向链表含环路,不要总是想到“0”型环路,还要想到“6”字型环路)
原本听到这道题时,我首先想到的笨办法就是:建一个足够大的一维数组,,每个位置放Node*类型指针。而后开始遍历单向链表,遍历过一个节点后就将该节点的指针添加到这个一维数组中,随后与该数组前边的所有元素进行一次遍历比较,如果有重复,则定位到了这个出现环路的节点。
但是后来面试官说:这个空间复杂度有点大,如果场景是有几百万条记录呢?有没有办法大大的降低这个时间复杂度? 因为是电面的,自己一时也没想出什么好办法来,惭愧惭愧~今天一早请教了下龙哥,龙哥给出了一个不错的思路,我测了一下,没有问题。
主体思路是:
从头结点开始遍历整个链表,没遍历过一个节点:就将其next置为NULL.这样:当往后遍历到某个节点:其next指向节点的next为NULL时变找到了。 注意:①很多人看到后会说:你这样不是破坏了原先的单向链表了吗?的确是这样,所以在考虑这种算法时还要同时考虑该如何进行恢复!最好是:使用完了之后接着恢复。而要做到这一点只能用递归来实现。(不过用递归貌似还是很大空间复杂度)
- struct Node
- {
- int data;
- int pNext;
- };
- void Fun(Node* pData,int currentPos,int& callbackPos)
- {
- if(pData[currentPos].pNext)
- {
- int backup = pData[currentPos].pNext; //记录下后继节点
- pData[currentPos].pNext = NULL;
- Fun(pData,backup,callbackPos);
- pData[currentPos].pNext = backup; //恢复后继节点
- }
- else
- {
- callbackPos = currentPos;
- }
- }
- int main()
- {
- //initilze array:
- Node* pData = new Node[7];
- for(int i=0;i<6;i++)
- {
- pData[i].pNext = i+1;
- }
- pData[6].pNext = 3;
- for(int i=0;i<7;i++)
- {
- pData[i].data = 10;
- }
- //-----------------------
- int callback = -1;
- Fun(pData,0,callback);
- printf("%d/n", callback);
- system("pause");
- return 0;
- }
所以:有时候递归用来处理这种既需要全局变化,又需要恢复的算法时很有用。
本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/NRC_DouNingBo/archive/2010/06/23/5688868.aspx
还有另外一篇介绍的方法,比这个方法要简答
有一个单向链表,如何判定这个链表当中是否包含有环路,以及如何定位环路在链表当中的开始点呢?
关于第一个问题,网络上可以搜索到,用两个指针来遍历这个单向链表,第一个指针p1,每次走一步;第二个指针p2,每次走两步; 当p2 指针追上 p1的时候,就表明链表当中有环路了。
关于这个解法最形象的比喻就是在操场当中跑步,速度快的会把速度慢的扣圈
可以证明,p2追赶上p1的时候,p1一定还没有走完一遍环路,p2也不会跨越p1多圈才追上
我们可以从p2和p1的位置差距来证明,p2一定会赶上p1但是不会跳过p1的
因为p2每次走2步,而p1走一步,所以他们之间的差距是一步一步的缩小,4,3,2,1,0 到0的时候就重合了
根据这个方式,可以证明,p2每次走三步以上,并不总能加快检测的速度,反而有可能判别不出有环
比如,在环的周长L是偶数的时候,初始p2和p1相差奇数的时候,p2每次走三步,就永远和p1不重合,因为他们之间的差距是: 5, 3 , 1, L-1, L-3
关于第二个问题,如何找到环路的入口,是这里要重点说明的内容:
解法如下: 当p2按照每次2步,p1每次一步的方式走,发现p2和p1重合,确定了单向链表有环路了
接下来,让p2回到链表的头部,重新走,每次步长不是走2了,而是走1,那么当p1和p2再次相遇的时候,就是环路的入口了。
这点可以证明的:
在p2和p1第一次相遇的时候,假定p1走了n步骤,环路的入口是在p步的时候经过的,那么有
p1走的路径: p+c = n; c为p1和p2相交点,距离环路入口的距离
p2走的路径: p+c+k*L = 2*N; L为环路的周长,k是整数
显然,如果从p+c点开始,p1再走n步骤的话,还可以回到p+c这个点
同时p2从头开始走的话,经过n不,也会达到p+c这点
显然在这个步骤当中p1和p2只有前p步骤走的路径不同,所以当p1和p2再次重合的时候,必然是在链表的环路入口点上
- #include "iostream.h"
- #include "memory.h"
- #include "new.h"
- class CList {
- public:
- int nData;
- CList * pNext;
- } * pRoot = NULL;
- const int size = sizeof(CList) / sizeof(int);
- int buffer[101*size];
- bool Init(int n)
- {
- pRoot = (CList*)buffer;
- if ( n<1 && n>98 ) return false;
- CList * pTemp = NULL;
- for ( int i=0; i<101; i++ ) {
- pTemp = new (buffer+i*size) CList();
- pTemp->nData = i;
- pTemp->pNext = (CList *)(buffer + (i+1)*size);
- };
- pTemp->pNext = (CList *) (buffer + n*size);
- return true;
- }
- void ClearCircle(CList * pRoot)
- {
- CList * p1, * p2;
- p1 = p2 = pRoot;
- do {
- p2 = p2->pNext->pNext;
- p1 = p1->pNext;
- } while ( p2!=NULL && p1!=p2); //这里有问题吧,如果p2->pNext为NULL,p2->pNext->pNext就指向未知位置了,有危险,所以应该加上 p2->pNext!=NULL判断条件
- if ( p1 == p2 ) {
- p2 = pRoot;
- while (1) {
- p2 = p2->pNext;
- if ( p1->pNext == p2 ) break;
- p1 = p1->pNext;
- }
- p1->pNext = NULL;
- }
- }
- main()
- {
- CList * pList = pRoot;
- if (Init(21) )
- {
- cout << "Before clear:!" << "/r/n";
- pList = pRoot;
- for ( int i=0; i<104; i++)
- {
- cout << pList->nData << "/r/n";
- pList = pList->pNext;
- }
- ClearCircle(pRoot);
- }
- cout << "After clear:" << "/r/n";
- pList = pRoot;
- while (pList) {
- cout << pList->nData << "/r/n";
- pList = pList->pNext;
- }
- return 0;
- }
本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/happy__888/archive/2005/12/21/558356.aspx