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

1. /********************************************************************************************************
3. *
5. *
7. * 设计双向链表的接口
9. *
11. *
13. *
15. * Copyright (c)  2023-2024   a1583839363@163.com   All right Reserved
17. * ******************************************************************************************************/
20. //指的是双向链表中的结点有效数据类型，用户可以根据需要进行修改
21. typedef int DataType_t;
23. //构造双向链表的结点,链表中所有结点的数据类型应该是相同的
24. typedef struct DoubleLinkedList
25. {
26.     DataType_t               data; //结点的数据域
27.     struct DoubleLinkedList *prev; //直接前驱的指针域
28.     struct DoubleLinkedList *next; //直接后继的指针域
30. }DoubleLList_t;
32. //创建一个空双向链表，空链表应该有一个头结点，对链表进行初始化
33. DoubleLList_t * DoubleLList_Create(void)
34. {
35.     //1.创建一个头结点并对头结点申请内存
36.     DoubleLList_t *Head = (DoubleLList_t *)calloc(1,sizeof(DoubleLList_t));
37.     if (NULL == Head)
38.     {
39.         perror("Calloc memory for Head is Failed");
40.         exit(-1);
41.     }
43.     //2.对头结点进行初始化，头结点是不存储数据域，指针域指向NULL
44.     Head->prev = NULL;
45.     Head->next = NULL;
47.     //3.把头结点的地址返回即可
48.     return Head;
49. }
51. //创建新的结点，并对新结点进行初始化（数据域 + 指针域）
52. DoubleLList_t * DoubleLList_NewNode(DataType_t data)
53. {
54.     //1.创建一个新结点并对新结点申请内存
55.     DoubleLList_t *New = (DoubleLList_t *)calloc(1,sizeof(DoubleLList_t));
56.     if (NULL == New)
57.     {
58.         perror("Calloc memory for NewNode is Failed");
59.         return NULL;
60.     }
62.     //2.对新结点的数据域和指针域（2个）进行初始化
63.     New->data = data;
64.     New->prev = NULL;
65.     New->next = NULL;
67.     return New;
68. }
70. //头插
71. bool DoubleLList_HeadInsert(DoubleLList_t *Head,DataType_t data)
72. {
73.     // 1.创建新的结点，并对新结点进行初始化
74.     DoubleLList_t *New = DoubleLList_NewNode(data);
75.     if (NULL == New)
76.     {
77.         printf("can not insert new node\n");
78.         return false;
79.     }
81.     // 2.判断双向链表是否为空，如果为空，则直接插入即可
82.     if (NULL == Head->next)
83.     {
84.         Head->next = New;
85.         return true;
86.     }
88.     // 3.如果双向链表为非空，把新结点插入到链表的头部\
89.     New->next = Head->next;
90.     Head->next->prev = New;
91.     Head->next = New;
93.     return true;
94. }
96. //尾插
97. bool DoubleLList_TailInsert(DoubleLList_t *Head,DataType_t data)
98. {
99.     // 1.创建新的结点，并对新结点进行初始化
100.     DoubleLList_t *New = DoubleLList_NewNode(data);
101.     if (NULL == New)
102.     {
103.         printf("can not insert new node\n");
104.         return false;
105.     }
107.     // 2.判断双向链表是否为空，如果为空，则直接插入即可
108.     if (NULL == Head->next)
109.     {
110.         Head->next = New;
111.         return true;
112.     }
114.     // 3.如果双向链表为非空，遍历链表，找到尾结点
115.     DoubleLList_t *Tail = Head;
116.     while(Tail->next != NULL)
117.     {
118.         Tail = Tail->next;
119.     }
121.     // 4.把新结点插入到链表的尾部
122.     Tail->next = New;
123.     New->prev = Tail;
125.     return true;
126. }
128. //指定插
129. bool DoubleLList_DestInsert(DoubleLList_t *Head,DataType_t destval,DataType_t data)
130. {
131.     // 1.创建新的结点，并对新结点进行初始化
132.     DoubleLList_t *New = DoubleLList_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.         return true;
144.     }
146.     // 3.如果双向链表为非空，遍历链表，找到插入位置
147.     DoubleLList_t *Dest = Head->next;
148.     while (Dest->data != destval && Dest != NULL)
149.     {
150.         Dest = Dest->next;
151.     }
152.     if (NULL == Dest)
153.     {
154.         return false;
155.     }
157.     // 4.说明找到目标结点，则把新结点插入到目标结点的后面
158.     New->next = Dest->next;
159.     Dest->next->prev = New;
160.     New->prev = Dest;
161.     Dest->next = New;
163.     return true;
164. }
166. //头删
167. bool DoubleLList_HeadDel(DoubleLList_t *Head)
168. {
169.     // 1.判断链表是否为空，如果为空，则直接退出
170.     if (NULL == Head->next)
171.     {
172.         return false;
173.     }
175.     // 2.对链表的首结点的地址进行备份
176.     DoubleLList_t *Temp = Head->next;
178.     // 3.链表是非空的，则直接删除首结点
179.     Head->next = Temp->next;
180.     Temp->next = NULL;
181.     Temp->next->prev = NULL;
182.     free(Temp);
184.     return true;
185. }
187. // 尾删
188. bool DoubleLList_TailDel(DoubleLList_t *Head)
189. {
190.     // 1.判断链表是否为空，如果为空，则直接退出
191.     if (NULL == Head->next)
192.     {
193.         return false;
194.     }
196.     // 2.遍历链表，找到尾结点
197.     DoubleLList_t *Tail = Head;
198.     while (Tail->next != NULL)
199.     {
200.         Tail = Tail->next;
201.     }
203.     // 3.删除尾结点
204.     Tail->prev->next = NULL;
205.     Tail->prev = NULL;
206.     free(Tail);
208.     return true;
209. }
211. // 指定删
212. bool DoubleLList_DestDel(DoubleLList_t *Head, DataType_t destval, DataType_t data)
213. {
214.     // 1.判断链表是否为空，如果为空，则直接退出
215.     if (NULL == Head->next)
216.     {
217.         return false;
218.     }
220.     // 2.链表是非空的，遍历链表，找到待删除结点
221.     DoubleLList_t *Dest = Head;
222.     while (Dest->data != destval && Dest != NULL)
223.     {
224.         Dest = Dest->next;
225.     }
226.     if (NULL == Dest)
227.     {
228.         return false;
229.     }
231.     // 3.删除指定结点
232.     Dest->prev->next = Dest->next;
233.     Dest->next->prev = Dest->prev;
234.     Dest->prev = NULL;
235.     Dest->next = NULL;
236.     free(Dest);
238.     return true;
239. }
241. //遍历链表
242. bool DoubleLList_Print(DoubleLList_t *Head)
243. {
244.     //对双向链表的头结点的地址进行备份
245.     DoubleLList_t *Phead = Head;
246.     //判断当前链表是否为空，为空则直接退出
247.     if (Head->next == Head)
248.     {
249.         printf("current linkeflist is empty!\n");
250.         return false;
251.     }
253.     //从首结点开始遍历
254.     while(Phead->next)
255.     {
256.         //把头结点的直接后继作为新的头结点
257.         Phead = Phead->next;
259.         //输出头结点的直接后继的数据域
260.         printf("data = %d\n",Phead->data);
262.         //判断是否到达尾结点，尾结点的next指针是指向首结点的地址
263.         if (Phead->next == Head->next)
264.         {
265.             break;
266.         }
267.     }
269.     return true;
270. }
272. int main(int argc, char const *argv[])
273. {
274.     return 0;
275. }

复制代码

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