C语言单向循环链表的增删操作

1. /********************************************************************************************************
2. *
3. *
4. * 设计单向循环链表的接口
5. *
6. *
7. *
8. * Copyright (c)  2023-2024   a1583839363@163.com   All right Reserved
9. * ******************************************************************************************************/
12. //指的是单向循环链表中的结点有效数据类型，用户可以根据需要进行修改
13. typedef int  DataType_t;
15. //构造单向循环链表的结点,链表中所有结点的数据类型应该是相同的
16. typedef struct CircularLinkedList
17. {
18.         DataType_t                   data; //结点的数据域
19.         struct LinkedList        *next; //结点的指针域
21. }CircLList_t;
24. //创建一个空单向循环链表，空链表应该有一个头结点，对链表进行初始化
25. CircLList_t * CircLList_Create(void)
26. {
27.         //1.创建一个头结点并对头结点申请内存
28.         CircLList_t *Head = (CircLList_t *)calloc(1,sizeof(CircLList_t));
29.         if (NULL == Head)
30.         {
31.                 perror("Calloc memory for Head is Failed");
32.                 exit(-1);
33.         }
35.         //2.对头结点进行初始化，头结点是不存储数据域，指针域指向自身，体现“循环”思想
36.         Head->next = Head;
38.         //3.把头结点的地址返回即可
39.         return Head;
40. }
42. //创建新的结点，并对新结点进行初始化（数据域 + 指针域）
43. CircLList_t * CircLList_NewNode(DataType_t data)
44. {
45.         //1.创建一个新结点并对新结点申请内存
46.         CircLList_t *New = (CircLList_t *)calloc(1,sizeof(CircLList_t));
47.         if (NULL == New)
48.         {
49.                 perror("Calloc memory for NewNode is Failed");
50.                 return NULL;
51.         }
53.         //2.对新结点的数据域和指针域进行初始化
54.         New->data = data;
55.         New->next = NULL;
57.         return New;
58. }
60. //头插
61. bool CircLList_HeadInsert(CircLList_t *Head,DataType_t data)
62. {
63.         // 1.创建新的结点，并对新结点进行初始化
64.         CircLList_t *New = CircLList_NewNode(data);
65.         if (NULL == New)
66.         {
67.                 printf("can not insert new node\n");
68.                 return false;
69.         }
71.         // 2.判断单向循环链表是否为空，如果为空，则直接插入即可
72.         if (NULL == Head->next)
73.         {
74.                 Head->next = New;
75.         New->next = New;
76.                 return true;
77.         }
79.     // 3.如果单向循环链表为非空，遍历找到尾结点
80.     CircLList_t *Last = Head;
81.     while(Last->next != Head->next)
82.     {
83.         Last = Last->next;
84.     }
86.         // 4.把新结点插入到链表的头部
87.     New->next = Head->next;
88.     Head->next = New;
89.     Last->next = New;
91.     return true;
92. }
94. //尾插
95. bool CircLList_TailInsert(CircLList_t *Head,DataType_t data)
96. {
97.         // 1.创建新的结点，并对新结点进行初始化
98.         CircLList_t *New = CircLList_NewNode(data);
99.         if (NULL == New)
100.         {
101.                 printf("can not insert new node\n");
102.                 return false;
103.         }
105.         // 2.判断单向循环链表是否为空，如果为空，则直接插入即可
106.         if (NULL == Head->next)
107.         {
108.                 Head->next = New;
109.         New->next = New;
110.                 return true;
111.         }
113.     // 3.如果单向循环链表为非空，遍历找到尾结点
114.     CircLList_t *Last = Head;
115.     while(Last->next != Head->next)
116.     {
117.         Last = Last->next;
118.     }
120.     // 4.把新结点插入到链表的尾部
121.     Last->next = New;
122.     New->next = Head->next;
124.     return true;
125. }
128. //指定位置插入
129. bool CircLList_DestInsert(CircLList_t *Head,DataType_t destval,DataType_t data)
130. {
131.         // 1.创建新的结点，并对新结点进行初始化
132.         CircLList_t *New = CircLList_NewNode(data);
133.         if (NULL == New)
134.         {
135.                 printf("can not insert new node\n");
136.                 return false;
137.         }
139.         // 2.判断单向循环链表是否为空，如果为空，则直接插入即可
140.         if (NULL == Head->next)
141.         {
142.                 Head->next = New;
143.         New->next = New;
144.                 return true;
145.         }
147.     // 3.遍历链表，比较结点的数据域，找到目标结点
148.         CircLList_t *Dest = Head->next;
149.         while (Dest->data != destval && Dest != NULL)
150.         {
151.                 Dest = Dest->next;
152.         }
153.         if (NULL == Dest)
154.         {
155.                 return false;
156.         }
158.         // 4.说明找到目标结点，则把新结点插入到目标结点的后面
159.         New->next = Dest->next;
160.         Dest->next = New;
162.     return true;
163. }
165. // 头删
166. bool CircLList_HeadDel(CircLList_t *Head)
167. {
168.         // 1.判断链表是否为空，如果为空，则直接退出
169.         if (NULL == Head->next)
170.         {
171.                 return false;
172.         }
174.     // 2.对链表的首结点的地址进行备份
175.         CircLList_t *Temp = Head->next;
177.         // 3.链表是非空的，遍历链表，找到尾结点
178.     CircLList_t *Last = Head;
179.     while(Last->next != Head->next)
180.     {
181.         Last = Last->next;
182.     }
184.     // 4.删除首结点
185.         Last->next = Temp->next;
186.     Head->next = Temp->next;
187.         Temp->next = NULL;
188.         free(Temp);
190.         return true;
191. }
193. // 尾删
194. bool CircLList_TailDel(CircLList_t *Head)
195. {
196.     // 1.判断链表是否为空，如果为空，则直接退出
197.         if (NULL == Head->next)
198.         {
199.                 return false;
200.         }
202.     // 2.链表是非空的，遍历链表，找到尾结点以及尾结点的直接前驱
203.     CircLList_t *Last_pre = Head;
204.     CircLList_t *Last = Head->next;
205.     while(Last->next != Head->next)
206.     {
207.         Last = Last->next;
208.         Last_pre = Last_pre->next;
209.     }
211.     // 3.删除尾结点
212.     Last_pre->next = Head->next;
213.     Last->next = NULL;
214.     free(Last);
216.         return true;
217. }
219. // 指定删
220. bool CircLList_DestDel(CircLList_t *Head, DataType_t destval, DataType_t data)
221. {
222.     // 1.判断链表是否为空，如果为空，则直接退出
223.         if (NULL == Head->next)
224.         {
225.                 return false;
226.         }
228.     // 2.链表是非空的，遍历链表，找到待删除结点以及待删除结点的直接前驱
229.         CircLList_t *Dest_pre = Head;
230.     CircLList_t *Dest = Head->next;
231.     while (Dest->data != destval && Dest != NULL)
232.         {
233.                 Dest = Dest->next;
234.         Dest_pre = Dest_pre->next;
235.         }
236.         if (NULL == Dest)
237.         {
238.                 return false;
239.         }
241.     // 3.删除指定结点
242.         Dest_pre->next = Dest->next;
243.     Dest->next = NULL;
244.         free(Dest);
246.         return true;
247. }
249. //遍历链表
250. bool CircLList_Print(CircLList_t *Head)
251. {
252.         //对单向循环链表的头结点的地址进行备份
253.         CircLList_t *Phead = Head;
254.        
255.         //判断当前链表是否为空，为空则直接退出
256.         if (Head->next == Head)
257.         {
258.                 printf("current linkeflist is empty!\n");
259.                 return false;
260.         }
262.         //从首结点开始遍历
263.         while(Phead->next)
264.         {
265.                 //把头结点的直接后继作为新的头结点
266.                 Phead = Phead->next;
268.                 //输出头结点的直接后继的数据域
269.                 printf("data = %d\n",Phead->data);
271.                 //判断是否到达尾结点，尾结点的next指针是指向首结点的地址
272.                 if (Phead->next == Head->next)
273.                 {
274.                         break;
275.                 }       
276.         }
278.         return true;
279. }
281. int main(int argc, char const *argv[])
282. {
283.        
284.         return 0;
285. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。