代码判断单链表是否有环

一、单链表环的定义：

有环的定义是，链表的尾节点指向了链接中间的某个节点。比如下图，如果单链表有环，则在遍历时，在通过结点J之后，会重新回到结点D。

题目：0.如何判断单链表里面是否有环？

算法的思想是设定两个指针p, q，其中p每次向前移动一步，q每次向前移动两步。那么如果单链表存在环，则p和q相遇；否则q将首先遇到null。
这里主要理解一个问题，就是为什么当单链表存在环时，p和q一定会相遇呢？

假定单链表的长度为n，并且该单链表是环状的，那么第i次迭代时，p指向元素i mod n，q指向2i mod n。因此当i≡2i(mod n)时，p与q相遇。而i≡2i(mod n) => (2i - i) mod n = 0 => i mod n = 0 => 当i=n时，p与q相遇。这里一个简单的理解是，p和q同时在操场跑步，其中q的速度是p的两倍，当他们两个同时出发时，p跑一圈到达起点，而q此时也刚 好跑完两圈到达起点。
那么当p与q起点不同呢？假定第i次迭代时p指向元素i mod n，q指向k+2i mod n，其中0<k<n。那么i≡(2i+k)(mod n) => (i+k) mod n = 0 => 当i=n-k时，p与q相遇。

解决方案：

推广：

1. 如果两个指针的速度不一样，比如p，q，( 0<p<q)二者满足什么样的关系，可以使得两者肯定交与一个节点？

    Sp(i) = pi

    Sq(i) = k + qi

   如果两个要相交于一个节点，则 Sp(i) = Sq(i) =>  (pi) mod n = ( k+ qi ) mod n =>[ (q -p)i + k ]  mod n =0

   =>  (q-p)i + k  = Nn [N 为自然数]

   =>  i = (Nn -k) /(p-q)

   i取自然数，则当 p，q满足上面等式 即 存在一个自然数N，可以满足Nn -k 是 p - q 的倍数时，保证两者相交。

   特例：如果q 是p 的步长的两倍，都从同一个起点开始，即 q = 2p , k =0, 那么等式变为： Nn=i： 即可以理解为，当第i次迭代时，i是圈的整数倍时，两者都可以交，交点就是为起点。

2.如何判断单链表的环的长度？

   这个比较简单，知道q 已经进入到环里，保存该位置。然后由该位置遍历，当再次碰到该q 位置即可，所迭代的次数就是环的长度。

3. 如何找到链表中第一个在环里的节点？

   假设链表长度是L，前半部分长度为k-1，那么第一个再环里的节点是k，环的长度是 n， 那么当q=2p时， 什么时候第一次相交呢？当q指针走到第k个节点时，q指针已经在环的第 k mod n 的位置。即p和q 相差k个元素，从不同的起点开始，则相交的位置为 n-k, 则有了下面的图：

从图上可以明显看到，当p从交点的位置（n-k) ,向前遍历k个节点就到到达环的第一个几点，节点k.

算法就很简单： 一个指针从p和q 中的第一次相交的位置起（n-k)，另外一个指针从链表头开始遍历，其交点就是链表中第一个在环里的交点。

4. 如果判断两个单链表有交？第一个交点在哪里？

    这个问题画出图，就可以很容易转化为前面的题目。

    

    将其中一个链表中的尾节点与头节点联系起来，则很容发现问题转化为问题3，求有环的链表的第一个在环里的节点。

二、代码实现

[cpp] view plaincopy

1. #include <stdio.h>  
2.   
3. typedef struct Node  
4. {  
5.     int val;  
6.     Node *next;  
7. }Node,*pNode;  
8.   
9.   
10.   
11. //判断是否有环  
12. bool isLoop(pNode pHead)  
13. {  
14.     pNode fast = pHead;  
15.     pNode slow = pHead;  
16.     //如果无环，则fast先走到终点  
17.     //当链表长度为奇数时，fast->Next为空  
18.     //当链表长度为偶数时，fast为空  
19.     while( fast != NULL && fast->next != NULL)  
20.     {  
21.   
22.         fast = fast->next->next;  
23.         slow = slow->next;  
24.         //如果有环，则fast会超过slow一圈  
25.         if(fast == slow)  
26.         {  
27.             break;  
28.         }  
29.     }  
30.   
31.     if(fast == NULL || fast->next == NULL  )  
32.         return false;  
33.     else  
34.         return true;  
35. }  
36.   
37. //计算环的长度  
38. int loopLength(pNode pHead)  
39. {  
40.     if(isLoop(pHead) == false)  
41.         return 0;  
42.     pNode fast = pHead;  
43.     pNode slow = pHead;  
44.     int length = 0;  
45.     bool begin = false;  
46.     bool agian = false;  
47.     while( fast != NULL && fast->next != NULL)  
48.     {  
49.         fast = fast->next->next;  
50.         slow = slow->next;  
51.         //超两圈后停止计数，挑出循环  
52.         if(fast == slow && agian == true)  
53.             break;  
54.         //超一圈后开始计数  
55.         if(fast == slow && agian == false)  
56.         {             
57.             begin = true;  
58.             agian = true;  
59.         }  
60.   
61.         //计数  
62.         if(begin == true)  
63.             ++length;  
64.           
65.     }  
66.     return length;  
67. }  
68.   
69.   
70. //求出环的入口点  
71. Node* findLoopEntrance(pNode pHead)  
72. {  
73.     pNode fast = pHead;  
74.     pNode slow = pHead;  
75.     while( fast != NULL && fast->next != NULL)  
76.     {  
77.   
78.         fast = fast->next->next;  
79.         slow = slow->next;  
80.         //如果有环，则fast会超过slow一圈  
81.         if(fast == slow)  
82.         {  
83.             break;  
84.         }  
85.     }  
86.     if(fast == NULL || fast->next == NULL)  
87.         return NULL;  
88.     slow = pHead;  
89.     while(slow != fast)  
90.     {  
91.         slow = slow->next;  
92.         fast = fast->next;  
93.     }  
94.   
95.     return slow;  
96. }  

三、判断是否有环的方法

1> 算法的思想是设定两个指针p, q，其中p每次向前移动一步，q每次向前移动两步。那么如果单链表存在环，则p和q相遇；否则q将首先遇到null。

//using step1 and step2 here//if exists a loop, then the pointer which use step2 will catch up with the pointer which uses step1int HasLoop(LinkList L){    int step1 = 1;    int step2 = 2;    LinkList p = L;    LinkList q = L;    //while (p != NULL && q != NULL && q->next == NULL)    while (p != NULL && q != NULL && q->next != NULL)    {        p = p->next;        if (q->next != NULL)            q = q->next->next;        printf("p:%d, q:%d \n", p->data, q->data);        if (p == q)            return 1;    }    return 0;}

2>.设两个工作指针p、q，p总是向前走，但q每次都从头开始走，对于每个节点，看p走的步数是否和q一样。比如p从A走到D，用了4步，而q则用了14步。因而步数不等，出现矛盾，存在环

//if two pointer are equal, but they don't have the same steps, then has a loopint HasLoop(LinkList L){    LinkList cur1 = L;  // 定义结点 cur1    int pos1 = 0;       // cur1 的步数    while(cur1){        // cur1 结点存在        LinkList cur2 = L;  // 定义结点 cur2        int pos2 = 0;       // cur2 的步数        pos1 ++;            // cur1 步数自增        while(cur2){        // cur2 结点不为空            pos2 ++;        // cur2 步数自增            if(cur2 == cur1){   // 当cur1与cur2到达相同结点时                if(pos1 == pos2)    // 走过的步数一样                    break;          // 说明没有还                else                // 否则                    return 1;       // 有环并返回1            }            cur2 = cur2->next;      //  如果没发现环，继续下一个结点        }        cur1 = cur1->next;  // cur1继续向后一个结点    }    return 0;}

3>完整代码

#include "stdio.h"#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define MAXSIZE 20 /* 存储空间初始分配量 */typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */typedef struct Node{    ElemType data;    struct Node *next;}Node;/* 定义LinkList */typedef struct Node *LinkList;/* 初始化顺序线性表 */Status InitList(LinkList *L){    *L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */    if(!(*L)) /* 存储分配失败 */    {        return ERROR;    }    (*L)->next=NULL; /* 指针域为空 */    return OK;}/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */int ListLength(LinkList L){    int i=0;    LinkList p=L->next; /* p指向第一个结点 */    while(p)    {        i++;        p=p->next;    }    return i;}/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */Status ClearList(LinkList *L){LinkList p,q;p=(*L)->next;           /*  p指向第一个结点 */while(p)                /*  没到表尾 */{q=p->next;free(p);p=q;}(*L)->next=NULL;        /* 头结点指针域为空 */return OK;}/* 初始条件：顺序线性表L已存在 *//* 操作结果：依次对L的每个数据元素输出 */Status ListTraverse(LinkList L){    LinkList p=L->next;    while(p)    {        visit(p->data);        p=p->next;    }    printf("\n");    return OK;}Status visit(ElemType c){    printf("-> %d ",c);    return OK;}/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) *//* 操作结果：用e返回L中第i个数据元素的值 */Status GetElem(LinkList L,int i,ElemType *e){int j;LinkList p;/* 声明一结点p */p = L->next;/* 让p指向链表L的第一个结点 */j = 1;/*  j为计数器 */while (p && j < i)  /* p不为空或者计数器j还没有等于i时，循环继续 */{p = p->next;  /* 让p指向下一个结点 */++j;}if ( !p || j>i )return ERROR;  /*  第i个元素不存在 */*e = p->data;   /*  取第i个元素的数据 */return OK;}/* 初始条件：顺序线性表L已存在 *//* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 *//* 若这样的数据元素不存在，则返回值为0 */int LocateElem(LinkList L,ElemType e){    int i=0;    LinkList p=L->next;    while(p)    {        i++;        if(p->data==e) /* 找到这样的数据元素 */                return i;        p=p->next;    }    return 0;}/*  随机产生n个元素的值，建立带表头结点的单链线性表L（头插法） */void CreateListHead(LinkList *L, int n){LinkList p;int i;srand(time(0));                         /* 初始化随机数种子 */*L = (LinkList)malloc(sizeof(Node));(*L)->next = NULL;                      /*  先建立一个带头结点的单链表 */for (i=0; i < n; i++){p = (LinkList)malloc(sizeof(Node)); /*  生成新结点 */p->data = rand()%100+1;             /*  随机生成100以内的数字 */p->next = (*L)->next;(*L)->next = p;/*  插入到表头 */}}/*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */void CreateListTail(LinkList *L, int n){LinkList p,r;int i;srand(time(0));                      /* 初始化随机数种子 */*L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */r=*L;                                /* r为指向尾部的结点 */for (i=0; i < n; i++){p = (Node *)malloc(sizeof(Node)); /*  生成新结点 */p->data = rand()%100+1;           /*  随机生成100以内的数字 */r->next=p;                        /* 将表尾终端结点的指针指向新结点 */r = p;                            /* 将当前的新结点定义为表尾终端结点 */}r->next = NULL;                       /* 表示当前链表结束 */}/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， *//* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */Status ListInsert(LinkList *L,int i,ElemType e){int j;LinkList p,s;p = *L;     /* 声明一个结点 p，指向头结点 */j = 1;while (p && j < i)     /* 寻找第i个结点 */{p = p->next;++j;}if (!p || j > i)return ERROR;   /* 第i个元素不存在 */s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */s->data = e;s->next = p->next;      /* 将p的后继结点赋值给s的后继  */p->next = s;          /* 将s赋值给p的后继 */return OK;}/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) *//* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */Status ListDelete(LinkList *L,int i,ElemType *e){int j;LinkList p,q;p = *L;j = 1;while (p->next && j < i)/* 遍历寻找第i个元素 */{        p = p->next;        ++j;}if (!(p->next) || j > i)    return ERROR;           /* 第i个元素不存在 */q = p->next;p->next = q->next;/* 将q的后继赋值给p的后继 */*e = q->data;               /* 将q结点中的数据给e */free(q);                    /* 让系统回收此结点，释放内存 */return OK;}/* 单链表反转/逆序 */Status ListReverse(LinkList L){    LinkList current,pnext,prev;    if(L == NULL || L->next == NULL)        return L;    current = L->next;  /* p1指向链表头节点的下一个节点 */    pnext = current->next;    current->next = NULL;    while(pnext)    {        prev = pnext->next;        pnext->next = current;        current = pnext;        pnext = prev;    }    //printf("current = %d,next = %d \n",current->data,current->next->data);    L->next = current;  /* 将链表头节点指向p1 */    return L;}Status ListReverse2(LinkList L){    LinkList current, p;    if (L == NULL)    {        return NULL;    }    current = L->next;    while (current->next != NULL)    {        p = current->next;        current->next = p->next;        p->next = L->next;        L->next = p;        ListTraverse(L);        printf("current = %d, \n", current -> data);    }    return L;}Status ListReverse3(LinkList L){    LinkList newList;    //新链表的头结点    LinkList tmp;       //指向L的第一个结点，也就是要摘除的结点    //参数为空或者内存分配失败则返回NULL    if (L == NULL || (newList = (LinkList)malloc(sizeof(Node))) == NULL)    {        return NULL;    }    //初始化newList    newList->data = L->data;    newList->next = NULL;    //依次将L的第一个结点放到newList的第一个结点位置    while (L->next != NULL)    {        tmp = newList->next;         //保存newList中的后续结点        newList->next = L->next;       //将L的第一个结点放到newList中        L->next = L->next->next;     //从L中摘除这个结点        newList->next->next = tmp;        //恢复newList中后续结点的指针    }    //原头结点应该释放掉，并返回新头结点的指针    free(L);    return newList;}// 获取单链表倒数第N个结点值Status GetNthNodeFromBack(LinkList L, int n, ElemType *e){    int i = 0;    LinkList firstNode = L;    while (i < n && firstNode->next != NULL)    {        //正数N个节点，firstNode指向正的第N个节点        i++;        firstNode = firstNode->next;        printf("%d\n", i);    }    if (firstNode->next == NULL && i < n - 1)    {        //当节点数量少于N个时，返回NULL        printf("超出链表长度\n");        return ERROR;    }    LinkList secNode = L;    while (firstNode != NULL)    {        //查找倒数第N个元素        secNode = secNode->next;        firstNode = firstNode->next;        //printf("secNode:%d\n", secNode->data);        //printf("firstNode:%d\n", firstNode->data);    }    *e = secNode->data;    return OK;}// 找到链表的中间节点Status GetMidNode(LinkList L, ElemType *e) {    LinkList search, mid;    mid = search = L;    while (search->next != NULL)    {        //search移动的速度是 mid 的2倍        if (search->next->next != NULL)        {            search = search->next->next;            mid = mid->next;            //printf("search %d\n", search->data);            //printf("mid %d\n", mid->data);        }        else        {            search = search->next;        }    }    *e = mid->data;    return OK;}int HasLoop(LinkList L){    int step1 = 1;    int step2 = 2;    LinkList p = L;    LinkList q = L;    //while (p != NULL && q != NULL && q->next == NULL)    while (p != NULL && q != NULL && q->next != NULL)    {        p = p->next;        if (q->next != NULL)            q = q->next->next;        printf("p:%d, q:%d \n", p->data, q->data);        if (p == q)            return 1;    }    return 0;}int HasLoop2(LinkList L){    int step1 = 1;    int step2 = 2;    LinkList p = L;    LinkList q = L;    while (p != NULL && q != NULL && q->next != NULL)    {        p = p->next;        if (q->next != NULL)            q = q->next->next;        printf("p:%d, q:%d \n", p->data, q->data);        if (p == q)            return 1;    }    return 0;}int main(){    LinkList L;    Status i;    int j,k,pos,value;    int opp;    ElemType e;    i=InitList(&L);    printf("链表L初始化完毕，ListLength(L)=%d\n",ListLength(L));    printf("\n1.整表创建（头插法） \n2.整表创建（尾插法） \n3.遍历操作 \n4.插入操作");    printf("\n5.删除操作 \n6.获取结点数据 \n7.查找某个数是否在链表中 \n8.置空链表");    printf("\n9.链表反转逆序 \n10.求链表倒数第N个数 \n11.找到链表的中间结点 \n12.判断链表是否有环");    printf("\n0.退出 \n请选择你的操作：\n");    while(opp != '0'){        scanf("%d",&opp);        switch(opp){            case 1:                CreateListHead(&L,10);                printf("整体创建L的元素(头插法)：\n");                ListTraverse(L);                printf("\n");                break;            case 2:                CreateListTail(&L,10);                printf("整体创建L的元素(尾插法)：\n");                ListTraverse(L);                printf("\n");                break;            case 3:                ListTraverse(L);                printf("\n");                break;            case 4:                printf("要在第几个位置插入元素？");                scanf("%d",&pos);                printf("插入的元素值是多少？");                scanf("%d",&value);                ListInsert(&L,pos,value);                ListTraverse(L);                printf("\n");                break;            case 5:                printf("要删除第几个元素？");                scanf("%d",&pos);                ListDelete(&L,pos,&e);                printf("删除第%d个元素成功，现在链表为：\n", pos);                ListTraverse(L);                printf("\n");                break;            case 6:                printf("你需要获取第几个元素？");                scanf("%d",&pos);                GetElem(L,pos,&e);                printf("第%d个元素的值为：%d\n", pos, e);                printf("\n");                break;            case 7:                printf("输入你需要查找的数：");                scanf("%d",&pos);                k=LocateElem(L,pos);                if(k)                    printf("第%d个元素的值为%d\n",k,pos);                else                    printf("没有值为%d的元素\n",pos);                printf("\n");                break;            case 8:                i=ClearList(&L);                printf("\n清空L后：ListLength(L)=%d\n",ListLength(L));                ListTraverse(L);                printf("\n");                break;            case 9:                ListReverse2(L);                //L=ListReverse3(L);                printf("\n反转L后\n");                ListTraverse(L);                printf("\n");                break;            case 10:                printf("你要查找倒数第几个结点的值？");                scanf("%d", &value);                GetNthNodeFromBack(L,value,&e);                printf("倒数第%d个元素的值为：%d\n", value, e);                printf("\n");                break;            case 11:                GetMidNode(L, &e);                printf("链表中间结点的值为：%d\n", e);                printf("\n");                break;            case 12:                if( HasLoop(L) )                {                    printf("方法一: 链表有环\n");                }                else                {                    printf("方法一: 链表无环\n");                }                if( HasLoop2(L) )                {                    printf("方法二: 链表有环\n");                }                else                {                    printf("方法二: 链表无环\n");                }                printf("\n");                break;            case 0:                exit(0);        }    }}