1. 循环链表的规则？

    循环链表的运算实现算法和非循环链表运算算法基本相同，之是对表尾的判断做了改变。例如，在头结点为*h的循环单链表中，判断表空的条件为h->next==h,判断*p为尾结点的条件是p->next==h

  2. 循环链表的实现。


  3. /*

  4. 循环链表：

  5. 判断表空的条件是:h->next=h;

  6. 判断结点是否是尾结点:l->next=h;

  7. */

  8. #include<stdio.h>

  9. #include<malloc.h>

  10. #include<stdlib.h>

  11. typedef struct node

  12. {

  13. int data;

  14. struct node *next;

  15. }NODE,*PNODE;

  16. PNODE createList(PNODE);

  17. void travleList(PNODE);

  18. void insertList(PNODE,int,int);

  19. void delList(PNODE,int,int *);

  20. int lengthList(PNODE);

  21. bool isEmpty(PNODE);

  22. void main()

  23. {

  24. PNODE phead=(PNODE)malloc(sizeof(NODE));

  25. if(phead==NULL)

  26. {

  27. printf("内存分配失败");

  28. exit(-1);

  29. }

  30. phead->next=phead;

  31. //创建循环链表

  32. phead=createList(phead);

  33. //遍历循环链表

  34. travleList(phead);

  35. //单循环链表插入

  36. printf("开始插入结点");

  37. insertList(phead,3,5);

  38. //遍历循环链表

  39. travleList(phead);

  40. //单循环链表删除

  41. printf("开始删除结点");

  42. int val;

  43. delList(phead,2,&val);

  44. //遍历循环链表

  45. travleList(phead);

  47. }

  48. PNODE createList(PNODE phead)

  49. {

  50. PNODE ptail=phead;

  51. int len,val;

  52. printf("请输入需要创建结点的个数:");

  53. scanf("%d",&len);

  54. for(int i=0;i<len;i++)

  55. {

  56. PNODE pnew=(PNODE)malloc(sizeof(NODE));

  57. if(NULL==pnew)

  58. {

  59. printf("内存分配失败");

  60. exit(-1);

  61. }

  62. printf("请给第%d个结点赋值",i+1);

  63. scanf("%d",&val);

  64. pnew->next=NULL;

  65. pnew->data=val;

  66. //开始组成循环单链表

  67. pnew->next=phead;//都指向头结点。

  68. ptail->next=pnew;//用一个替代结点来帮助变换。

  69. ptail=pnew;

  70. }

  71. return phead;


  73. }

  74. void travleList(PNODE phead)

  75. {

  76. PNODE pnew=phead->next;

  77. while(pnew!=phead)

  78. {

  79. printf("%d ",pnew->data);

  80. pnew=pnew->next;

  81. }

  82. printf("\n");

  83. }

  84. void insertList(PNODE phead,int pos,int val)

  85. {

  86. PNODE pnew=phead;

  87. int i=0;

  88. // 传统插入方法。不能使用哪个高效算法。

  89. if(pnew==NULL||pos<1||pos>lengthList(phead)+1)

  90. {

  91. printf("无法插入");

  92. return;

  93. }

  94. while(i<pos-1)

  95. {

  96. pnew=pnew->next;

  97. i++;

  98. }

  99. //开始插入

  100. //造出新结点,并初始化

  101. PNODE p=(PNODE)malloc(sizeof(NODE));

  102. if(NULL==p)

  103. {

  104. printf("内存分配失败");

  105. exit(-1);

  106. }

  107. p->next=NULL;

  108. p->data=val;

  109. //准备插入

  110. p->next=pnew->next;

  111. pnew->next=p;

  112. }

  113. void delList(PNODE phead,int pos,int *val)

  114. {

  115. int i=0;

  116. PNODE pnew=phead;

  117. if(pnew==NULL||pos<1||pos>lengthList(phead))

  118. {

  119. printf("无法删除");

  120. return;

  121. }

  122. while(i<pos-1)

  123. {

  124. pnew=pnew->next;

  125. i++;

  126. }

  127. //开始删除

  128. PNODE q=pnew->next;

  129. *val=q->data;

  130. printf("%d          ",*val);

  131. pnew->next=pnew->next->next;

  132. free(q);

  133. }

  134. int lengthList(PNODE phead)

  135. {

  136. // 主要不需要插入结点，就不需要创造结点，申请内存pnew=(PNODE)malloc(sizeof(NODE));,遍历长度，根本不需要

  137. int i=0;

  138. PNODE pnew=phead;

  139. while(pnew->next!=phead)

  140. {

  141. pnew=pnew->next;

  142. i++;

  143. }

  144. return i;


  146. }

  147. bool isEmpty(PNODE phead)

  148. {

  149. if(phead->next==phead)

  150. return true;

  151. else 

  152. return false;

  153. }