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

1. // 指的是单向链表中的结点有效数据类型，用户可以根据需要进行修改
2. typedef int DataType_t;
4. // 构造链表的结点,链表中所有结点的数据类型应该是相同的
5. typedef struct LinkedList
6. {
7.     DataType_t data;         // 结点的数据域
8.     struct LinkedList *next; // 结点的指针域
10. } LList_t;
12. // 创建一个空链表，空链表应该有一个头结点，对链表进行初始化
13. LList_t *LList_Create(void)
14. {
15.     // 1.创建一个头结点并对头结点申请内存
16.     LList_t *Head = (LList_t *)calloc(1, sizeof(LList_t));
17.     if (NULL == Head)
18.     {
19.         perror("Calloc memory for Head is Failed");
20.         exit(-1);
21.     }
23.     // 2.对头结点进行初始化，头结点是不存储有效内容的！！！
24.     Head->next = NULL;
26.     // 3.把头结点的地址返回即可
27.     return Head;
28. }
30. // 创建新的结点，并对新结点进行初始化（数据域 + 指针域）
31. LList_t *LList_NewNode(DataType_t data)
32. {
33.     // 1.创建一个新结点并对新结点申请内存
34.     LList_t *New = (LList_t *)calloc(1, sizeof(LList_t));
35.     if (NULL == New)
36.     {
37.         perror("Calloc memory for NewNode is Failed");
38.         return NULL;
39.     }
41.     // 2.对新结点的数据域和指针域进行初始化
42.     New->data = data;
43.     New->next = NULL;
45.     return New;
46. }
48. // 头插
49. bool LList_HeadInsert(LList_t *Head, DataType_t data)
50. {
51.     // 1.创建新的结点，并对新结点进行初始化
52.     LList_t *New = LList_NewNode(data);
53.     if (NULL == New)
54.     {
55.         printf("can not insert new node\n");
56.         return false;
57.     }
59.     // 2.判断链表是否为空，如果为空，则直接插入即可
60.     if (NULL == Head->next)
61.     {
62.         Head->next = New;
63.         return true;
64.     }
66.     // 3.如果链表为非空，则把新结点插入到链表的头部
67.     New->next = Head->next;
68.     Head->next = New;
70.     return true;
71. }
73. // 尾插
74. bool LList_TailInsert(LList_t *Head, DataType_t data)
75. {
77.     // 1.创建新的结点，并对新结点进行初始化
78.     LList_t *New = LList_NewNode(data);
79.     if (NULL == New)
80.     {
81.         printf("can not insert new node\n");
82.         return false;
83.     }
85.     // 2.判断链表是否为空，如果为空，则直接插入即可
86.     if (NULL == Head->next)
87.     {
88.         Head->next = New;
89.         return true;
90.     }
92.     // 3.如果链表为非空，则把新结点插入到链表的尾部
93.     LList_t *Last = Head;
94.     while (Last->next != NULL)
95.     {
96.         Last = Last->next;
97.     }
98.     New->next = NULL;
99.     Last->next = New;
101.     return true;
102. }
104. // 指定插
105. bool LList_DestInsert(LList_t *Head, DataType_t dest, DataType_t data)
106. {
107.     // 1.创建新的结点，并对新结点进行初始化
108.     LList_t *New = LList_NewNode(data);
109.     if (NULL == New)
110.     {
111.         printf("can not insert new node\n");
112.         return false;
113.     }
115.     // 2.判断链表是否为空，如果为空，则直接插入即可
116.     if (NULL == Head->next)
117.     {
118.         Head->next = New;
119.         return true;
120.     }
122.     // 3.如果链表为非空，则把新结点插入到链表的指定位置
123.     LList_t *Dest = Head;
124.     while (Dest->data != dest)
125.     {
126.         Dest = Dest->next;
127.     }
128.     New->next = Dest->next;
129.     Dest->next = New;
131.     return true;
132. }
134. // 头删
135. bool LList_HeadDel(LList_t *Head, DataType_t data)
136. {
137.     LList_t *Temp = Head->next;
138.     Head->next = Temp->next;
139.     free(Temp);
141.     return true;
142. }
144. // 尾删
145. bool LList_TailDel(LList_t *Head, DataType_t data)
146. {
147.     LList_t *SecondLast = Head;
148.     while (SecondLast->next->next != NULL)
149.     {
150.         SecondLast = SecondLast->next;
151.     }
152.     free(SecondLast->next);
153.     SecondLast->next = NULL;
155.     return true;
156. }
158. // 指定删
159. bool LList_DestDel(LList_t *Head, DataType_t dest, DataType_t data)
160. {
161.     LList_t *LDest = Head;
162.     while ((LDest->next)->data != dest)
163.     {
164.         LDest = LDest->next;
165.     }
166.     LDest->next = LDest->next->next;
167.     free(LDest->next);
168.     return true;
169. }
171. // 设计一个算法删除单链表L(有头结点)中的一个最小值结点
172. bool LList_MinDel(LList_t *Head, DataType_t data)
173. {
174.     LList_t *LDest = Head;
175.     LList_t *LMin = LDest;
176.     while (LDest->next != NULL)
177.     {
178.         if ((LDest->next)->data < (LMin->next)->data)
179.         {
180.             LMin->next = LDest->next;
181.             LMin = LDest;
182.         }
183.         LDest = LDest->next;
184.         LDest->next = LDest->next->next;
185.     }
186.     LMin->next = LMin->next->next;
187.     free(LMin->next);
188.     return true;
189. }
191. // 遍历
192. void LList_Print(LList_t *Head)
193. {
194.     // 对链表的头文件的地址进行备份
195.     LList_t *Phead = Head;
197.     // 首结点
198.     while (Phead->next)
199.     {
200.         // 把头的直接后继作为新的头结点
201.         Phead = Phead->next;
203.         // 输出头结点的直接后继的数据域
204.         printf("data = %d\n", Phead->data);
205.     }
206. }
208. int main(int argc, char const *argv[])
209. {
210.     return 0;
211. }

复制代码

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