循环链表逻辑

Question

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head == null){
            return false;
        }
          ListNode slow = head;
          ListNode fast = head.next;

          while((slow != null) && (fast != null) && (slow.next != null) && (fast.next != null)){
            if(slow == fast){
                return true;
            }
            slow = slow.next;
            fast = fast.next.next;

          }

          return false;
    }
}

为了检测循环链表，我们使用2指针技术，慢速和快速。

我的问题是，如果列表是循环列表，我怎么知道指针必须在某个点相交？

Answer 1

看看手表。这是一个数字 1 到 12 的循环列表，然后循环回到 1。

大手快，小手慢，都在同一个方向，从同一个点开始（top = 12）。

因为列表（边）是圆形的，所以大手最终会追上小手。多快取决于速度差异，但它会赶上。如果赶上，列表必须是循环的。

如果它没有赶上，但到达列表末尾，则列表不是循环的。

即使列表没有回到开头，例如如果12转回9，快手会一直转，直到小手进入圈子，然后快手最终会追上小手。

好的，对于最后一部分，手表的形象不太好，但我希望你明白了。

Answer 2

证据并不像看起来那么明显。

实际上，只要稍加改动就能使快速指针变得更快，例如使用fast = fast.next.next.next，算法不再保证可以工作。

重要的是两个指针的相对速度。

在标准情况下，相对速度为 2 - 1 = 1，这意味着在每一步中，快指针与慢指针接近一个单位。这样就保证了快的一个会追上来，不会跳过另一个。

否则，例如如果相对速度是 3 - 1 = 2，那么它们可能永远不会相交。如果我们从指针之间的奇数距离开始，并且循环长度是偶数，就会发生这种情况。在这种情况下，距离将始终保持奇数（因此永远不会为零）。

---

为了清楚说明如果不注意速度差异，指针可能不会相交，考虑速度为 3 的快指针和速度为 1 的慢指针，循环运行有 4 个节点，标记为 0、1 , 2, 3，形成这样的循环 0 -> 1 -> 2 -> 3 -> 0。

假设最初，慢速指针位于节点 0，而快速指针位于节点 1。（请注意，这不是一个强假设，并且可能无法通过不同的初始化策略来缓解 - 无论初始化方法如何, 可能是图中还有一些额外的节点，而不是循环的一部分，这使得指针在它们都到达循环后就可能处于任意位置。

在k 步骤之后，慢指针将位于节点k mod 4。快速节点将位于节点(1 + 3k) mod 4。假设有一个k 使得快慢指针在同一位置，这意味着(1 + 3k) mod 4 = k mod 4，即(1 + 2k) mod 4 = 0。但左边是奇数，所以不能为零。因此，指针可以指向同一个节点的假设是矛盾的。

Answer 3

好吧，正如安德烈亚斯所说，看看手表，但如果这仍然没有意义，那么this 可能会有所帮助。

另外，您可以稍微简化一下代码：

public boolean isCyclic(Node first) {
    if(first == null) {
      return false;
    }
    Node fast = first;
    Node slow = first;
    while(fast.getNext() != null && fast.getNext().getNext() != null) {
      slow = slow.getNext();
      fast = fast.getNext().getNext();
      if(slow == fast) {
        return true;
      }
    }
    return false;
}

• 从http://codecramp.com/linked-list-loop-detection/复制的代码

我也认为你应该用 head 而不是 head.next

来初始化你的 fast 指针

Answer 4

下面是C语言循环链表的完整实现：​​

#include <stdio.h>
#include <stdlib.h>
struct node {
int data;
struct node* next;
};
void insert(struct node** head,int ele){
struct node* temp = (struct node*)malloc(sizeof(struct node));
struct node* ptr;
temp->data = ele;
temp->next = temp;
if(*head == NULL){
    *head = temp;
}else{
    ptr = *head;
    while(ptr->next != *head){
        ptr = ptr->next;
    }
    ptr->next = temp;
    temp->next = *head;
}
}
void deleteLastEle(struct node** head){
struct node* current = *head;
struct node* pre = *head;
while(current->next != *head){
    pre = current;
    current = current->next;
}
pre->next = current->next;
free(current);
}
void deleteAtPos(struct node** head,int pos){
struct node* current = *head;
struct node* pre = *head;
for(int i=0;i<pos-1;i++){
    pre = current;
    current = current->next;
}
pre->next = current->next;
free(current);
}
void deleteFirst(struct node** head){
struct node* current = *head;
struct node* temp = *head;
while(current->next != *head){
    current = current->next;
}
current->next = (*head)->next;
*head = (*head)->next;
free(temp);
}
printCLL(struct node** head){
struct node* ptr = *head;
do{
    printf("%d ",ptr->data);
    ptr = ptr->next;
}while(ptr != *head);
printf("\n");
}
// main() function.
int main(void) {
struct node* head = NULL;
for(int i=0;i<5;i++){
    //function to insert elements in linked list
    insert(&head,i);
}
printf("inseted linkedlist: \n");
//print the content of linked list.
printCLL(&head);

//function to delete last element
deleteLastEle(&head);
printf("after deleting last element: \n");
printCLL(&head);

//function to delete element at pos 3.
deleteAtPos(&head,3);
printf("after deleting at pos 3: \n");
printCLL(&head);

//function to delete first element of linkedlust
deleteFirst(&head);
printf("after deleting first element: \n");
printCLL(&head);
return 0;
}

这些是输出：

inseted linkedlist: 
0 1 2 3 4 
after deleting last element: 
0 1 2 3 
after deleting at pos 3: 
0 1 3 
after deleting first element: 
1 3