面试题（循环链表）

题目为：对于普通的单向链表，如果实现确定其内部有一个环，如何确定何处出现环路的？单向链表每个节点中只有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); 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