在单向链表中查找循环

如果句柄上有几个节点的循环，你的内部循环将不会终止，例如，对于这样的事情，它将是一个无限循环：

1 -> 2 -> 3 -> 4 -> 5
          ^         |
          |         |
          +---------+

这个怎么样？

struct Node_
{
    int ix ;
    struct Node_* next ;
} ;
typedef struct Node_ NODE ;
NODE *head = NULL ;
int main()
{
    NODE* n1 ;
    n1 = (NODE*) malloc(sizeof(NODE)) ;
    n1->ix = 0 ;
    n1->next = NULL ;
    head = n1 ;
    NODE* n2 ;
    n2 = (NODE*) malloc(sizeof(NODE)) ;
    n2->ix = 1 ;
    n2->next = NULL ;
    n1->next = n2 ;
    NODE* n3 ;
    n3 = (NODE*) malloc(sizeof(NODE)) ;
    n3->ix = 2 ;
    n3->next = NULL ;
    n2->next = n3 ;
    NODE* n4 ;
    n4 = (NODE*) malloc(sizeof(NODE)) ;
    n4->ix = 3 ;
    n4->next = n2 ;
    n3->next = n4 ;
    unordered_map<NODE*,int> hashx ;
    int idx ;
    NODE* p = head ;
    while(p != NULL)
    {
        hashx[p] += 1 ;
        if(hashx[p] >= 2)
        {
            printf("node p (%d) recycle !!n",p->ix);
            break ;
        }
        p = p->next ;
    }
    printf("done n") ;
} //main

我的代码是否遗漏了什么

return; // no cycle detected

这行看起来很糟糕，应该改成 s.th。

return NULL; // no cycle detected

你的内部循环条件似乎是模棱两可的。您正在分析如果 （p==q） 其中 q 是下一个 p->。这意味着之前考虑的节点 P 没有一个周期。所以对我来说，你的内心循环永远不会终止。

您必须考虑这一点：-

#include <iostream>
using namespace std;
class Node{
    public:
        int data;
        Node * next;
        Node(int x){
            data = x;
            next = NULL;
        }
        Node(int x, Node * y){
            data = x; 
            next = y;
        }
};
class linkedList{
    Node *head;
    public:
        linkedList(){
            head = NULL;
        }
        void addNode(int value){
            Node *p;
            if(head == NULL)
                head = new Node (value, NULL);
            else{
                p = head;
                while(p->next !=NULL)
                    p=p->next;
                    p->next = new Node (value, NULL);
            }
        }
        void print(){
            Node * p;
            p = head;
            while(p != NULL){
                cout << p->data;
                p = p->next;
            }
        }
        int findCycle(){
            Node *p, *start, *q;
            p = head;
            while(p != NULL){
                q = p->next;
                while (q != NULL ){
                    if(p->data == q->data)
                         return q->data;
                    else
                         q = q->next;
                }
                p = p->next;
            }
            return 0;
        }
};
int main(){
    linkedList l1;
    l1.addNode(1);
    l1.addNode(2);
    l1.addNode(3);
    l1.addNode(4);
    l1.addNode(5);
    l1.addNode(3);
    int node = l1.findCycle();
    cout<<node;
    return 0;
}

你怎么说人们关于这个代码。

void LinkListOps::createCycledListAndFindACycleNode()

{ 构建包含循环的列表

ZNODE* head = new ZNODE(0);
ZNODE* current = head;
ZNODE* cycle = 0;
for (int i = 1; i < 8; i++)
{
    current->_next = new ZNODE(i);
    current = current->_next;
    if (i == 6)
        cycle = current;
    if (i == 7)
        current->_next = cycle;
}
// verify that there is a cycle
ZNODE* slow = head;
ZNODE* fast = head;
ZNODE* cycleNode = 0;
while (slow && fast && fast->_next)
{
    slow = slow->_next;
    fast = fast->_next->_next;
    if (slow == fast)
    {
        cycleNode = slow;
        break;
    }
}
if (cycleNode == 0)
{
    printf("No cyclen");
    return;
}
// finally find a cycle node which will be p2
ZNODE* p1 = head;
ZNODE* p2 = cycleNode;
while (1)
{
    for (p2 = cycleNode; p2->_next != cycleNode; p2 = p2->_next)
    {
        if (p2 == p1)
            break;          
    }
    if (p2 == p1)
        break;
    p1 = p1->_next;
}
printf("%dn", p2->_i);

}

您可以通过执行以下操作快速确定链表中是否存在循环：

ptr = head;
current = nullptr;
if (!ptr) {
  current = ptr->next;
  while(current && current!=ptr) {
    current = current->next;
    if (current) {
      current = current->next;
    }
    ptr = ptr->next;
  }
}

最后，如果current不为 null，则找到一个循环，current将位于其中的某个位置。 这是通过迭代列表current速度是ptr的两倍来工作的，并且总是会在循环之前找到一个循环（如果有的话），ptr循环一次。