假设您在Java中有一个链表结构。它由节点组成:
class Node {
Node next;
// some user data
}
每个节点都指向下一个节点，除了最后一个节点，它的next为空。假设有一种可能性，列表可以包含一个循环-即最后的节点，而不是有一个空值，有一个引用到列表中它之前的一个节点。
最好的写作方式是什么
boolean hasLoop(Node first)
如果给定的节点是带有循环的列表的第一个，则返回true，否则返回false ?你怎么能写出一个常数的空间和合理的时间呢?
下面是一个带有循环的列表的图片:
当前回答
//链表查找循环函数
int findLoop(struct Node* head)
{
struct Node* slow = head, *fast = head;
while(slow && fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
if(slow == fast)
return 1;
}
return 0;
}
其他回答
乌龟和兔子
看看波拉德的算法。这不是完全相同的问题，但也许你会理解其中的逻辑，并将其应用于链表。
(如果你很懒，你可以看看周期检测——看看关于乌龟和兔子的那部分。)
这只需要线性时间和2个额外的指针。
在Java中:
boolean hasLoop( Node first ) {
if ( first == null ) return false;
Node turtle = first;
Node hare = first;
while ( hare.next != null && hare.next.next != null ) {
turtle = turtle.next;
hare = hare.next.next;
if ( turtle == hare ) return true;
}
return false;
}
(大多数解决方案不会同时检查next和next。接下来是null。此外，因为乌龟总是在后面，你不需要检查它是否为空——兔子已经检查过了。)
我不确定这个答案是否适用于Java，但我仍然认为它属于这里:
当我们在现代体系结构中使用指针时，我们可以期望它们是CPU字对齐的。对于64位体系结构，这意味着指针的前3位始终为零。这让我们可以使用这个内存来标记我们已经见过的指针，通过对它们的第一个比特写入1。
如果我们遇到一个指针，它的第一个位已经写了1，那么我们已经成功地找到了一个循环，之后我们需要再次遍历结构，并将这些位屏蔽掉。完成了!
这种方法被称为指针标记，它在低级编程中被过度使用，例如Haskell在一些优化中使用它。
下面的方法可能不是最好的——它是O(n²)。然而，它应该有助于完成工作(最终)。
count_of_elements_so_far = 0;
for (each element in linked list)
{
search for current element in first <count_of_elements_so_far>
if found, then you have a loop
else,count_of_elements_so_far++;
}
您甚至可以在常数O(1)时间内完成(尽管它不是非常快或有效):计算机内存可以容纳的节点数量是有限的，比如N条记录。如果遍历超过N条记录，那么就有一个循环。
在这个上下文中，到处都有文本材料的加载。我只是想张贴一个图表表示，真正帮助我掌握概念。
当快、慢在点p相遇时，
快速行进的距离= a+b+c+b = a+2b+c
慢行距离= a+b
因为快的比慢的快2倍。 所以a+2b+c = 2(a+b)然后得到a=c。
因此，当另一个慢指针再次从头部运行到q时，同时，快速指针将从p运行到q，因此它们在q点会合。
public ListNode detectCycle(ListNode head) {
if(head == null || head.next==null)
return null;
ListNode slow = head;
ListNode fast = head;
while (fast!=null && fast.next!=null){
fast = fast.next.next;
slow = slow.next;
/*
if the 2 pointers meet, then the
dist from the meeting pt to start of loop
equals
dist from head to start of loop
*/
if (fast == slow){ //loop found
slow = head;
while(slow != fast){
slow = slow.next;
fast = fast.next;
}
return slow;
}
}
return null;
}
