一个简朴的C语言制作的单链表

C_LINK_LIST

• 这是单链表和双链表的根本效果
  

点击查看代码

1. //single_link_list
2. struct NODE
3.     int value;
4.     struct NODE * next;
5. }
6. ```c
7. //double linked list
8. struct NODE{
9.     int value;
10.     struct NODE * previous;
11.     struct NODE * next;
12. }
15. 这是自己制作的一个C语言单链表，他的功能包括创建一个单链表，查找删除特定的值，并且实现倒序单链表。
16. 她的不足之处在于他无法在主函数中特定停止，等待用户进行输入。
17. This is my code.
18. ```c
19. #include <stdlib.h>
20. #include <stdio.h>
21. #include "singly_linked_list.h"
23. //struct  NODE * sll_reverse(struct NODE * first);
24. int sll_remove(Node ** rootp, int value);
25. int dll_insert(Node ** rootp, int value);
26. Node * sll_reverse(Node *first);
27. int main(){
28.     int num;
29.     Node *first = (Node *)malloc(sizeof(Node));
30.     if(first == NULL){
31.         perror("NO Buffle: ");
32.         return 1;
33.     }
34.     first->value = 3;
35.     first->link = NULL;
36.     Node *rootp = first;
37.     while (scanf("%d" , &num) != EOF){
38.         dll_insert(&rootp, num);
39.     }
40.     Node * ptr = rootp;
41.     printf("\n");
42.     while(ptr != NULL){
43.         printf(" %d", ptr->value);
44.         ptr = ptr->link;
45.     }
46.    /* getchar();getchar();
47.     printf("Input a single number you want to remove: ");
48.     getchar();
49.     while(scanf("%d", &num) != EOF){
50.         sll_remove(&rootp, num);
51.     }
52.     ptr = rootp;
53.     while(ptr != NULL){
54.         printf(" %d", ptr->value);
55.         ptr = ptr->link;
56.     }*/
57.     rootp = sll_reverse(rootp);
58.     printf("\n");
59.     ptr = rootp;
60.     while(ptr != NULL){
61.         printf(" %d", ptr->value);
62.         ptr = ptr->link;
63.     }
64.     ptr = rootp;
65.     while(ptr != NULL){
66.         Node * temp=ptr;
67.         ptr = ptr->link;
68.         free(temp);
69.     }
70.     return 0;
71. }
73. int dll_insert(Node ** rootp, int value){
74.     Node *previous = NULL;
75.     Node *current = *rootp;
76.     while(current != NULL && current->value < value){
77.         previous = current;
78.         current = current->link;
79.     }
80.     if (current != NULL && current-> value == value)
81.         return 0;
83.     Node *new = (Node *)malloc(sizeof(Node));
84.     if (new == NULL){
85.         perror("NO buffle : ");
86.         exit(EXIT_FAILURE);
87.     }
88.     new->value = value;
89.     new->link = current;
90.     if(previous != NULL){
91.         previous->link  = new;
92.     }
93.     else{
94.         *rootp = new;
95.     }
96.     return 0;
97. }
99. int sll_remove(Node ** rootp,int value){
100.     Node *previous = NULL;
101.     Node *current = *rootp;
102.    
103.     while(current != NULL && current->value != value){
104.         previous = current;
105.         current = current->link;
106.     }
107.     if(current != NULL){
108.         Node * temp = current;
109.         current = current->link;
110.         free(temp);
111.         if(previous != NULL){
112.             return 0;
113.         }
114.         else {
115.             *rootp = current;
116.             return 0;
117.         }
118.     }
119.     else {
120.         printf("No this module. ");
121.         return 1;
122.     }
123. }
124.         
126. Node * sll_reverse(Node * first){
127.     int i = 0;
128.     Node *temp = first;
129.     while(temp != NULL){
130.         temp = temp->link;
131.         i++;
132.     }
133.     if( i == 0){
134.         printf("None Node.");
135.         return first;
136.     }
137.     Node *array[i];
138.     temp = first;
139.     for(int j = 0; j< i;j++){
140.         ar#include <stdlib.h>
141. #include <stdio.h>
142. #include "singly_linked_list.h"
144. //struct  NODE * sll_reverse(struct NODE * first);
145. int sll_remove(Node ** rootp, int value);
146. int dll_insert(Node ** rootp, int value);
147. Node * sll_reverse(Node *first);
148. int main(){
149.     int num;
150.     Node *first = (Node *)malloc(sizeof(Node));
151.     if(first == NULL){
152.         perror("NO Buffle: ");
153.         return 1;
154.     }
155.     first->value = 3;
156.     first->link = NULL;
157.     Node *rootp = first;
158.     while (scanf("%d" , &num) != EOF){
159.         dll_insert(&rootp, num);
160.     }
161.     Node * ptr = rootp;
162.     printf("\n");
163.     while(ptr != NULL){
164.         printf(" %d", ptr->value);
165.         ptr = ptr->link;
166.     }
167.    /* getchar();getchar();
168.     printf("Input a single number you want to remove: ");
169.     getchar();
170.     while(scanf("%d", &num) != EOF){
171.         sll_remove(&rootp, num);
172.     }
173.     ptr = rootp;
174.     while(ptr != NULL){
175.         printf(" %d", ptr->value);
176.         ptr = ptr->link;
177.     }*/
178.     rootp = sll_reverse(rootp);
179.     printf("\n");
180.     ptr = rootp;
181.     while(ptr != NULL){
182.         printf(" %d", ptr->value);
183.         ptr = ptr->link;
184.     }
185.     ptr = rootp;
186.     while(ptr != NULL){
187.         Node * temp=ptr;
188.         ptr = ptr->link;
189.         free(temp);
190.     }
191.     return 0;
192. }
194. int dll_insert(Node ** rootp, int value){
195.     Node *previous = NULL;
196.     Node *current = *rootp;
197.     while(current != NULL && current->value < value){
198.         previous = current;
199.         current = current->link;
200.     }
201.     if (current != NULL && current-> value == value)
202.         return 0;
204.     Node *new = (Node *)malloc(sizeof(Node));
205.     if (new == NULL){
206.         perror("NO buffle : ");
207.         exit(EXIT_FAILURE);
208.     }
209.     new->value = value;
210.     new->link = current;
211.     if(previous != NULL){
212.         previous->link  = new;
213.     }
214.     else{
215.         *rootp = new;
216.     }
217.     return 0;
218. }
220. int sll_remove(Node ** rootp,int value){
221.     Node *previous = NULL;
222.     Node *current = *rootp;
223.    
224.     while(current != NULL && current->value != value){
225.         previous = current;
226.         current = current->link;
227.     }
228.     if(current != NULL){
229.         Node * temp = current;
230.         current = current->link;
231.         free(temp);
232.         if(previous != NULL){
233.             return 0;
234.         }
235.         else {
236.             *rootp = current;
237.             return 0;
238.         }
239.     }
240.     else {
241.         printf("No this module. ");
242.         return 1;
243.     }
244. }
245.         
247. Node * sll_reverse(Node * first){
248.     int i = 0;
249.     Node *temp = first;
250.     while(temp != NULL){
251.         temp = temp->link;
252.         i++;
253.     }
254.     if( i == 0){
255.         printf("None Node.");
256.         return first;
257.     }
258.     Node *array[i];
259.     temp = first;
260.     for(int j = 0; j< i;j++){
261.         array[j] = temp;
262.         temp = temp->link;
263.     }
264.     Node *new =  array[i-1];
265.     for(int k = i-1;k >= 0;k--){
266.         temp = array[k];
267.         if(k != 0){
268.             temp->link = array[k-1];
269.         }
270.         else{
271.             temp->link = NULL;
272.         }
273.     }
274.     return new;
275. }
276. ray[j] = temp;
277.         temp = temp->link;
278.     }
279.     Node *new =  array[i-1];
280.     for(int k = i-1;k >= 0;k--){
281.         temp = array[k];
282.         if(k != 0){
283.             temp->link = array[k-1];
284.         }
285.         else{
286.             temp->link = NULL;
287.         }
288.     }
289.     return new;
290. }

复制代码

头文件: single_link_list.h

1. typedef struct NODE {
2.     int value;
3.     struct NODE * link;
4. }Node;

复制代码

这是我制作的双链表
双链表与单链表的区别：单链表只能按某种顺序执行，而双链表在每个节点中都有前一个节点和后一个节点的指针，能够访问前一个节点和后一个节点。
这是我编写的双链表实现方式：

1. #include <stdio.h>
2. #include <stdlib.h>
4. typedef struct NODE {
5.     struct NODE * fwd;
6.     struct NODE * bwd;
7.     int value;
8. } Node;
10. Node * insert(Node *, int );
11. int main(){
12.     int new_value;
13.     Node * top;
14.     top = (Node *)malloc(sizeof(Node));
15.     if(top == NULL){
16.         perror("No memory: ");
17.         exit(EXIT_FAILURE);
18.     }
19.     top->bwd = NULL;
20.     top->fwd = NULL;
21.     printf("Hello linked list.\n");
22.     printf("Input some integet(-1 to quit). ");
23.     while((scanf("%d", &new_value) == 1) && new_value != -1){
24.         top=insert(top, new_value);
25.     }
26.     if(top->fwd == NULL){
27.         printf("NULL in top.\n");
28.         free(top);
29.         return 0;
30.     }
31.     for(Node * temp=top->fwd; temp != NULL; temp = temp->fwd){
32.         printf("%d ", temp->value);
33.     }
34.     //Node * current = top;
35.     Node * current = top->fwd;
36.     while(current != NULL){
37.         Node * temp = current;
38.         current = current->fwd;
39.         free(temp);
40.     }
41.     free(top);
42.     return 0;
43. }
45. Node * insert(Node * rootp, int value){
46.     Node * this;
47.     Node * next;
48.     Node * new;
49.    
50.     for (this = rootp; (next = this->fwd) != NULL ; this = next ){
51.         if(next->value == value)
52.             return rootp;
53.         if (this->value > value)
54.             break;
55.     }
56.     new = (Node *)malloc(sizeof(Node));
57.     if (new == NULL){
58.         perror("No memory: ");
59.         exit(EXIT_FAILURE);
60.     }
61.     new->value = value;
62.     if (next != NULL){
63.         new->fwd = next;
64.         if (this != rootp){
65.             this->fwd = new;
66.             new->bwd = this;
67.         }
68.         else{
69.             rootp->fwd = new;
70.             new->bwd = NULL;
71.         }
72.         next->bwd = new;
73.     }
74.     else{
75.         new->fwd = NULL;
76.         if(this != rootp){
77.             this->fwd = new;
78.             new->bwd = this;
79.         }
80.         else{
81.             rootp->fwd = new;
82.             new->bwd = NULL;
83.         }
84.         rootp->bwd = new;
85.     }
86.     return rootp;
87. }

复制代码

2025-04-08 12:37:42 星期二

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