Linux C 数据结构—-循环链表

前面我们学习了单向链表，现在介绍单向循环链表，单向循环链表是单链表的一种改进，若将单链表的首尾节点相连，便构成单向循环链表结构，如下图：

     对于一个循环链表来说,其首节点和末节点被连接在一起。这种方式在单向和双向链表中皆可实现。要转换一个循环链表，可以选择开始于任意一个节点然后沿着列表的任一方向直到返回开始的节点。再来看另一种方法，循环链表可以被视为“无头无尾”。这种列表很利于节约数据存储缓存， 假定你在一个列表中有一个对象并且希望所有其他对象迭代在一个非特殊的排列下。指向整个列表的指针可以被称作访问指针。
    循环链表中第一个节点之前就是最后一个节点，反之亦然。循环链表的无边界使得在这样的链表上设计算法会比普通链表更加容易。对于新加入的节点应该是在第一个节点之前还是最后一个节点之后可以根据实际要求灵活处理，区别不大。当然，如果只会在最后插入数据（或者只会在之前），处理也是很容易的。
      
      循环链表的应用

一、Joseph问题（约瑟夫环）：

     据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人找到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。 

     约瑟夫环用数学问题来描述就是：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。如何用循环链表来求解Josephu问题？

    下面我们用单向循环链表来模拟这个问题：

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. typedef int data_t;  
5.   
6. typedef struct node_t  
7. {  
8.     data_t data;  
9.     struct node_t *next;      
10. }linknode_t,*linklist;  
11.   
12. linklist CreateList(int n)  
13. {  
14.     int i;  
15.     linklist p,head,tail;  
16.     head = NULL;  
17.       
18.     for(i = 1;i <= n;i++)  
19.     {  
20.         p = (linklist)malloc(sizeof(linklist));  
21.         if(p == NULL)  
22.         {  
23.             printf("malloc fails!\n");  
24.         }  
25.               
26.         p->data = i;  
27.         if(head == NULL)  
28.         {  
29.             head = p;  
30.             tail = head;  
31.         }  
32.         else  
33.         {  
34.             tail->next = p;  
35.         }                 
36.           
37.         tail = p;  
38.     }  
39.       
40.     tail->next = head;  
41.   
42.     return head;   
43. }  
44.   
45. void Joseph(int n,int k,int m)  
46. {  
47.     int i;  
48.     linklist p,r;  
49.     p = CreateList(n);  
50.   
51.     for(i = 1;i < k;i++) //从第K个人开始数  
52.     {  
53.         p = p->next;  
54.     }  
55.   
56.     while(p->next != p)  
57.     {  
58.         for(i = 1;i <= m-2;i++)  //数到第m个人，去自杀  
59.             p = p->next;  
60.   
61.         r = p->next;  
62.         p->next = r->next;  
63.         printf("%d->",r->data);  
64.           
65.         free(r);  
66.         p = p->next;//从下一个人继续数  
67.     }  
68.       
69.     printf("%d\n",p->data);  
70. }  
71.   
72. int main()  
73. {  
74.     Joseph(41,1,3);  
75.   
76.     return 0;  
77. }  

输出结果如下：

[cpp] view plain copy

1. fs@ubuntu:~/qiang/linklist$ ./list1  
2. 3->6->9->12->15->18->21->24->27->30->33->36->39->1->5->10->14->19->23->28->32->37->41->7->13->20->26->34->40->8->17->29->38->11->25->2->22->4->35->16->31  

我们可以看到，最后两个是16和31，这样，约瑟夫和他的朋友就躲过了一劫！

二、判断一个链表是不是循环链表（如何判定这个链表当中是否包含有环路）

 解决方法：

      判断是否是循环链表时，也设置两个指针，慢指针和快指针，让快指针比慢指针每次移动快两次。如果快指针追赶上慢指针，则为循环链表，否则不是循环链表，如果快指针或者慢指针指向NULL，则不是循环链表。

代码如下：

[cpp] view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. typedef int data_t;  
5.   
6. typedef struct node_t  
7. {  
8.     data_t data;  
9.     struct node_t *next;      
10. }linknode_t,*linklist;  
11.   
12. linklist CreateList(int n)  
13. {  
14.     int i;  
15.     linklist p,head,tail;  
16.     head = NULL;  
17.       
18.     for(i = 1;i <= n;i++)  
19.     {  
20.         p = (linklist)malloc(sizeof(linklist));  
21.         if(p == NULL)  
22.         {  
23.             printf("malloc fails!\n");  
24.         }  
25.               
26.         p->data = i;  
27.         if(head == NULL)  
28.         {  
29.             head = p;  
30.             tail = head;  
31.         }  
32.         else  
33.         {  
34.             tail->next = p;  
35.         }                 
36.           
37.         tail = p;  
38.     }  
39.       
40.     tail->next = head;  
41.   
42.     return head;   
43. }  
44.   
45. int JudgeIsloop(linklist list)  
46. {  
47.     int flag = 0;  
48.     linknode_t *slow,*fast;  
49.   
50.     if(list == NULL)  
51.         return 0;  
52.   
53.     slow = list;  
54.     fast = list->next;  
55.   
56.     while(slow)  
57.     {  
58.         if(fast == NULL || fast->next == NULL)//走到头了  
59.             return 0;  
60.         else if(fast == slow || fast->next == slow)//二者相遇，因为fast走的快，如果fast->next指向slow，也是循环的  
61.         {     
62.             flag = 1;  
63.             return 1;  
64.         }  
65.         else  
66.         {  
67.             slow = slow->next;//慢指针走一步  
68.             fast = fast->next->next;//快指针走两步  
69.         }  
70.     }  
71.   
72.     return 0;  
73. }  
74.   
75. int main()  
76. {  
77.     int i;  
78.     int flag = 0;  
79.     linklist list;  
80.     list = CreateList(10);  
81.       
82.     JudgeIsloop(list);  
83.   
84.     if(flag = 0)  
85.         printf("The list is not a looplist!\n");  
86.     else  
87.     {  
88.         printf("The list is a looplist!\n");//循环链表则打印出来  
89.         for(i = 0;i < 10;i++)  
90.         {  
91.             printf("%d->",list->data);  
92.             list = list->next;  
93.         }  
94.         printf("%d\n",list->data);  
95.     }  
96.   
97.     return 0;  
98. }  

结果如下：

[cpp] view plain copy

1. fs@ubuntu:~/qiang/linklist$ ./list2  
2. The list is a looplist!  
3. 1->2->3->4->5->6->7->8->9->10->1  
4. fs@ubuntu:~/qiang/linklist$