单项循环链表
mian.c：
1 #include <stdio.h>
2 #include "./03_Sing_XUNHUAN_link_lists.h"
3
4 int main(int argc, const char *argv[])
5 {
6 Sing_xunhuan_linklists * head;
7 head = create_Sing_xunhuan_linklists();
8 heda_inset_linklists(head,20);
9 heda_inset_linklists(head,30);
10 heda_inset_linklists(head,40);
11 heda_inset_linklists(head,50);
12 heda_inset_linklists(head,60);
13 traverse_linklists(head);
14
15 heda_inset_linklists(head,23);//头插
16 traverse_linklists(head);//遍历
17 head_delete_linklists(head);//头删
18 traverse_linklists(head);
19 tail_inset_XUNHUAN_linklists(head,45);//尾插
20 traverse_linklists(head);
21 tail_delete_linklists(head);//尾删
22 traverse_linklists(head);
23 index_inset_linklists(head,3,63);//按位置插入
24 traverse_linklists(head);
25 index_delete_linklists(head,6);//按位置删除
26 traverse_linklists(head);
27 return 0;
28 }
函数：
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 #include "./03_Sing_XUNHUAN_link_lists.h"
5
6 //创建单向循环链表头结点
7 Sing_xunhuan_linklists* create_Sing_xunhuan_linklists(void)
8 {
9 //申请堆空间，将堆空间首地址赋給头指针head
10 Sing_xunhuan_linklists *head = (Sing_xunhuan_linklists*)malloc(sizeof(Sing_xunhuan_linklists));
11 //判断头指针是否为NULl
12 if(NULL == head)
13 {
14 printf("堆空间申请失败，头结点未创建");
15 return NULL;
16 }
17 head->text.len = 0;
18 head->next=head;
19 return head;
20 }
21 //头插
22 int heda_inset_linklists(Sing_xunhuan_linklists *head,datatype num)
23 {
24 Sing_xunhuan_linklists *p=head;
25 //创建一个新的结点首地址赋給temp
26 Sing_xunhuan_linklists *temp=(Sing_xunhuan_linklists*)malloc(sizeof(Sing_xunhuan_linklists));
27 //判断temp指针是否为NULl
28 if(NULL == temp)
29 {
30 printf("堆空间申请失败，结点未创建");
31 return -1;
32 }
33 temp->text.data=num;
34 temp->next=NULL;
35
36 //将头部结点的next给到插入的结点temp
37 temp->next=p->next;
38 p->next=temp;
39 //定义的链表长度len++
40 head->text.len++;
41 return 0;
42 }
43 //头删
44 int head_delete_linklists(Sing_xunhuan_linklists *head)
45 {
46 //防止头指针丢失建立一个p指针指向头部节点空间
47 Sing_xunhuan_linklists *p=head;
48 //判断单项循环链表是否为空
49 if(p->next==head)
50 {
51 printf("单向循环链表为空，无法执行头删操作");
52 return -1;
53 }
54 //创建一个指针temp用来保存被删除的结点首地址，防止内存泄漏
55 Sing_xunhuan_linklists *temp;
56 //将要被删除的结点拿出来
57 temp=p->next;
58 //让p->next等于被删除的后一个结点
59 p->next=temp->next;
60 //将拿出来的结点释放掉
61 free(temp);
62 temp = NULL;
63 //定义的链表长度len--
64 head->text.len--;
65 return 0;
66 }
67 //尾插
68 int tail_inset_XUNHUAN_linklists(Sing_xunhuan_linklists *head,datatype num)
69 {
70
71 Sing_xunhuan_linklists *p=head;
72 //创建一个新的结点首地址赋給temp
73 Sing_xunhuan_linklists *temp=(Sing_xunhuan_linklists*)malloc(sizeof(Sing_xunhuan_linklists));
74 //判断temp指针是否为NULl
75 if(NULL == temp)
76 {
77 printf("堆空间申请失败，结点未创建");
78 return -1;
79 }
80 temp->text.data=num;
81 temp->next=NULL;
82 //循环找到最后一个节点的位置
83 while(p->next!=head)
84 {
85 p=p->next;
86 }
87 //将新的结点插入到链表中
88 temp->next=p->next;
89 p->next=temp;
90 //定义的链表长度len++
91 head->text.len++;
92 return 0;
93 }
94 //尾删
95 int tail_delete_linklists(Sing_xunhuan_linklists *head)
96 {
97 //防止头指针丢失建立一个p指针指向头部节点空间
98 Sing_xunhuan_linklists *p=head;
99 //判断单项循环链表是否为空
00 if(p->next==head)
01 {
02 printf("单向循环链表为空，无法执行头删操作");
03 return -1;
04 }
05 //创建一个指针temp用来保存被删除的结点首地址，防止内存泄漏
06 Sing_xunhuan_linklists *temp;
07 //循环找到最后一个结点
08 while(p->next->next!=head)
09 {
10 p=p->next;
11 }
12 //将要删除的结点拿出来
13 temp=p->next;
14 //将被删除的后一个结点首地址赋給被删除的前一个结点的next
15 p->next=temp->next;
16
17 //释放掉需要被删除的结点
18 free(temp);
19 //将temp指针指向空，防止变成野指针
20 temp=NULL;
21 //定义的链表长度len--
22 head->text.len--;
23 return 0;
24 }
25 //按位置插入
26 int index_inset_linklists(Sing_xunhuan_linklists *head,int index,datatype num)
27 {
28 //申请一个结点的堆空间,结点首地址赋給temp
29 Sing_xunhuan_linklists *temp=(Sing_xunhuan_linklists*)malloc(sizeof(Sing_xunhuan_linklists));
30 //判断结点是否创建成功
31 if(NULL==temp)
32 {
33 printf("创建结点失败");
34 return -1;
35 }
36 //给结点的数据域data赋值
37 temp->text.data=num;
38 //给结点的指针域赋NULL
39 temp->next=NULL;
40 //防止头结点丢失，这里给它另存一下
41 Sing_xunhuan_linklists *p=head;
42 //循环判断到需要插入的位置
43 for(int i = 0;i<index-1;i++)
44 {
45 p=p->next;
46 }
47 //将新的结点插入到指定位置
48 temp->next=p->next;
49 p->next=temp;
50 //将头部节点中的数据域len++
51 head->text.len++;
52 return 0;
53 }
54 //按位置删除
55 int index_delete_linklists(Sing_xunhuan_linklists *head,int index)
56 {
57 //防止头指针丢失建立一个p指针指向头部节点空间
58 Sing_xunhuan_linklists *p=head;
59 //判断单项循环链表是否为空
60 if(p->next==head)
61 {
62 printf("单向循环链表为空，无法执行头删操作");
63 return -1;
64 }
65 //创建一个指针temp用来保存被删除的结点首地址，防止内存泄漏
66 Sing_xunhuan_linklists *temp;
67 //循环找到需要删除的结点位置
68 for(int i = 0;i<index-1;i++)
69 {
70 p=p->next;
71 }
72 //将要删除的结点拿出来
73 temp=p->next;
74 //将被删除的后一个结点首地址赋給被删除的前一个结点的next
75 p->next=temp->next;
76
77 //释放掉需要被删除的结点
78 free(temp);
79 //将temp指针指向空，防止变成野指针
80 temp=NULL;
81 //定义的链表长度len--
82 head->text.len--;
83 return 0;
84 }
85 //遍历输出
86 void traverse_linklists(Sing_xunhuan_linklists *head)
87 {
88 //将传进来的链表头指针用Sing_xunhuan_linklists类型的指针p接收
89 Sing_xunhuan_linklists* p= head->next;
90 //循环遍历链表
91 while(p->next!=head)
92 {
93 printf("%d ",p->text.data);
94 p=p->next;
95 }
96 putchar(10);
97 return;
98 }
头文件：
1 #ifndef __SING_XUNHUAN_LINKLISTS__
2 #define __SING_XUNHUAN_LINKLISTS__
3
4 //重命名int为datatype
5 typedef int datatype;
6 //创建sing_xunhuan_linklists类型结构体
7 typedef struct sing_xunhuan_linklists
8 {
9 union
0 {
1 int len; //链表长度
2 datatype data; //数据位
3 }text;
4 struct sing_xunhuan_linklists* next;//指针域
5 }Sing_xunhuan_linklists;
6
7
8 //创建单向循环链表头结点
9 Sing_xunhuan_linklists* create_Sing_xunhuan_linklists(void);
0 //头插
1 int heda_inset_linklists(Sing_xunhuan_linklists *head,datatype num);
2 //头删
3 int head_delete_linklists(Sing_xunhuan_linklists *head);
4 //尾插
5 int tail_inset_XUNHUAN_linklists(Sing_xunhuan_linklists *head,datatype num);
6 //尾删
7 int tail_delete_linklists(Sing_xunhuan_linklists *head);
8 //按位置插入
9 int index_inset_linklists(Sing_xunhuan_linklists *head,int index,datatype num);
0 //按位置删除
1 int index_delete_linklists(Sing_xunhuan_linklists *head,int index);
2 //遍历输出
3 void traverse_linklists(Sing_xunhuan_linklists *head);
4 #endif
输出结果：
双向循环链表：
主函数：
1 #include <stdio.h>
2 #include "./03_bidir_linklists.h"
3 int main(int argc, const char *argv[])
4 {
5 Bidir_linklists *head;
6 head=create_linklists();
7 inset_head_linklists(head,23);//头插
8 inset_head_linklists(head,33);//头插
9 inset_head_linklists(head,43);//头插
10 inset_head_linklists(head,53);//头插
11
12 traverse_linklists(head);//遍历链表
13 delete_head_linklists(head);//头删
14 traverse_linklists(head);
15 inset_tail_linklists(head,70);//尾插
16 traverse_linklists(head);
17 delete_tail_linklists(head);//尾删
18 traverse_linklists(head);
19 // dao_traverse_linklists(head);//使用prev倒叙遍历
20 index_inset_linklists(head,4,700);//按位置插入
21 traverse_linklists(head);
22 index_delete_linklists(head,3);
23 traverse_linklists(head);
24 return 0;
25 }
功能函数：
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include "./03_bidir_linklists.h"
4
5 //创建一个空的双向链表
6 Bidir_linklists* create_linklists(void)
7 {
8 //申请一个Bidir_linklists类型的堆空间结点，将首地址赋给head
9 Bidir_linklists *head=(Bidir_linklists*)malloc(sizeof(Bidir_linklists));
10 //判断结点是否申请成功
11 if(NULL==head)
12 {
13 printf("创建头结点失败");
14 return NULL;
15 }
16 //将头结点指针域和数据位len赋初值
17 head->text.len=0;
18 head->next=NULL;
19 head->prev=NULL;
20
21 return head;
22
23 }
24
25 //头插
26 int inset_head_linklists(Bidir_linklists *head,datatype num)
27 {
28 //将传进来的头指针另存
29 Bidir_linklists *p=head;
30 //申请一个Bidir_linklists类型的堆空间结点，将首地址赋给temp
31 Bidir_linklists *temp=(Bidir_linklists*)malloc(sizeof(Bidir_linklists));
32 //判断结点是否申请成功
33 if(NULL==temp)
34 {
35 printf("创建头结点失败");
36 return -1;
37 }
38 //将结点指针域和数据位data赋初值
39 temp->next=NULL;
40 temp->prev=NULL;
41 temp->text.data=num;
42
43 if(p->next==NULL)
44 {
45 //prev指针域存储前一个结点的首地址
46 temp->prev=p;
47 //将新的结点插入到双向链表
48 temp->next=p->next;
49 p->next=temp;
50
51 }else
52 {
53 //将新的结点插入到双向链表
54 temp->next=p->next;
55 p->next=temp;
56 //prev指针域存储前一个结点的首地址
57 temp->prev=p;
58 //temp的下一个结点存储temp的首地址
59 temp->next->prev=temp;
60 }
61 //头部结点len++
62 head->text.len++;
63
64
65 return 0;
66 }
67
68
69 //头删
70 int delete_head_linklists(Bidir_linklists *head)
71 {
72 //将传进来的头指针另存
73 Bidir_linklists *p=head;
74 //定义一个新的Bidir_linklists类型指针另存需要被删除的结点
75 Bidir_linklists *temp;
76 //判断链表是否为空
77 if(p->next==NULL)
78 {
79 printf("链表为空，无法执行头删");
80 }
81 //将需要删除的结点分离
82 temp=p->next;
83 p->next=temp->next;
84 //prev存入前一个结点的首地址
85 temp->next->prev=temp->prev;
86 //将分离出来的结点temp释放掉
87 free(temp);
88 //将temp置空，防止变成野指针
89 temp=NULL;
90 //头结点len--
91 head->text.len--;
92 return 0;
93 }
94 //尾插
95 int inset_tail_linklists(Bidir_linklists *head,datatype num)
96 {
97 //将传进来的头指针另存
98 Bidir_linklists *p=head;
99 //申请一个Bidir_linklists类型的堆空间结点，将首地址赋给temp
100 Bidir_linklists *temp=(Bidir_linklists*)malloc(sizeof(Bidir_linklists));
101 //判断结点是否申请成功
102 if(NULL==temp)
103 {
104 printf("创建头结点失败");
105 return -1;
106 }
107 //将结点指针域和数据位data赋初值
108 temp->next=NULL;
109 temp->prev=NULL;
110 temp->text.data=num;
111
112 //循环找到最后一个结点
113 while(p->next!=NULL)
114 {
115 p=p->next;
116 }
117 //将新的结点插入到双向链表
118 temp->next=p->next;
119 p->next=temp;
120 //prev指针域存储前一个结点的首地址
121 temp->prev=p;
122
123 //头部结点len++
124 head->text.len++;
125
126 return 0;
127 }
128 //尾删
129 int delete_tail_linklists(Bidir_linklists *head)
130 {
131 //将传进来的头指针另存
132 Bidir_linklists *p=head;
133 //定义一个新的Bidir_linklists类型指针另存需要被删除的结点
134 Bidir_linklists *temp;
135 //判断链表是否为空
136 if(p->next==NULL)
137 {
138 printf("链表为空，无法执行头删");
139 return -1;
140 }
141 //循环找到要删除的结点的前一个结点
142 while(p->next->next!=NULL)
143 {
144 p=p->next;
145 }
146 //将需要删除的结点分离
147 temp=p->next;
148 p->next=temp->next;
149 //将分离出来的结点temp释放掉
150 free(temp);
151 //将temp置空，防止变成野指针
152 temp=NULL;
153 //头结点len--
154 head->text.len--;
155 return 0;
156 }
157
158 //按位置插
159 int index_inset_linklists(Bidir_linklists *head,int index,datatype num)
160 {
161 //将传进来的头指针另存
162 Bidir_linklists *p=head;
163 //申请一个Bidir_linklists类型的堆空间结点，将首地址赋给temp
164 Bidir_linklists *temp=(Bidir_linklists*)malloc(sizeof(Bidir_linklists));
165 //判断结点是否申请成功
166 if(NULL==temp)
167 {
168 printf("创建头结点失败");
169 return -1;
170 }
171 //将结点指针域和数据位data赋初值
172 temp->next=NULL;
173 temp->prev=NULL;
174 temp->text.data=num;
175 //判断插入位置是否合法
176 if(index<0)
177 {
178 printf("插入位置非法");
179 return -1;
180 }
181 //循找到需要插入的位置
182 for(int i = 0;i<index-1;i++)
183 {
184 if(p==NULL)
185 {
186 printf("位置非法");
187 return -1;
188 }else
189 {
190 p=p->next;
191 }
192 }
193 if(p->next==NULL)
194 {
195 //prev指针域存储前一个结点的首地址
196 temp->prev=p;
197 //将新的结点插入到双向链表
198 temp->next=p->next;
199 p->next=temp;
200
201 }else
202 {
203 //将新的结点插入到双向链表
204 temp->next=p->next;
205 p->next=temp;
206 //prev指针域存储前一个结点的首地址
207 temp->prev=p;
208 //temp的下一个结点存储temp的首地址
209 temp->next->prev=temp;
210 }
211 //头部结点len++
212 head->text.len++;
213
214
215 return 0;
216 }
217 //按位置删
218 int index_delete_linklists(Bidir_linklists *head,int index)
219 {
220 //将传进来的头指针另存
221 Bidir_linklists *p=head;
222 //定义一个新的Bidir_linklists类型指针另存需要被删除的结点
223 Bidir_linklists *temp;
224 //判断链表是否为空
225 if(p->next==NULL)
226 {
227 printf("链表为空，无法执行删除");
228 return -1;
229 }
230 //判断插入位置是否合法
231 if(index<0)
232 {
233 printf("插入位置非法");
234 return -1;
235 }
236 //循环找到要删除的结点的前一个结点
237 for(int i = 0;i<index-1;i++)
238 {
239 p=p->next;
240 if(p==NULL)
241 {
242 printf("非法操作");
243 return -1;
244 }
245 }
246 if(p->next->next!=NULL)
247 {
248 //将需要删除的结点分离
249 temp=p->next;
250 p->next=temp->next;
251 //将被删的的结点的后一个结点的prev存储删除位子的前一个结点首地址
252 temp->next->prev=temp->prev;
253 }else
254 {
255 //将需要删除的结点分离
256 temp=p->next;
257 p->next=temp->next;
258 }
259 //将分离出来的结点temp释放掉
260 free(temp);
261 //将temp置空，防止变成野指针
262 temp=NULL;
263 //头结点len--
264 head->text.len--;
265 return 0;
266 }
267
268 //遍历链表
269 void traverse_linklists(Bidir_linklists *head)
270 {
271 //将传进来的头指针另存
272 Bidir_linklists *p=head;
273 //使用循环遍历链表
274 while(p->next!=NULL)
275 {
276 p=p->next;
277 printf("%d ",p->text.data);
278 }
279 putchar(10);
280 return;
281 }
282 //倒叙遍历
283 void dao_traverse_linklists(Bidir_linklists *head)
284 {
285 //将传进来的头指针另存
286 Bidir_linklists *p=head;
287 //循环找到要最后的结点
288 while(p->next!=NULL)
289 {
290 p=p->next;
291 }
292 //使用循环遍历链表
293 while(p->prev!=NULL)
294 {
295 printf("%d ",p->text.data);
296 p=p->prev;
297 }
298 putchar(10);
299 return;
300 }
301
头文件：
1 #ifndef __BIDIR_LINKLISTS__
2 #define __BIDIR_LINKLISTS__
3 //重命名int为datatype
4 typedef int datatype;
5
6 //创建一个一个数据域两个指针域的结构体
7 typedef struct bidir_linklists
8 {
9 union{
10 int len; //数据域，计算有效数据长度，只有头结点会做处理
11 datatype data; //数据域，存储当前节点的数据
12 }text; //数据域
13 struct bidir_linklists *prev;//指针域，存储上一个节点的首地址
14 struct bidir_linklists *next;//指针域，存储下一个结点的首地址
15 }Bidir_linklists;
16 //创建一个空的双向链表
17 Bidir_linklists* create_linklists(void);
18 //头插
19 int inset_head_linklists(Bidir_linklists *head,datatype num);
20 //遍历链表
21 void traverse_linklists(Bidir_linklists *head);
22 //头删
23 int delete_head_linklists(Bidir_linklists *head);
24 //尾插
25 int inset_tail_linklists(Bidir_linklists *head,datatype num);
26 //尾删
27 int delete_tail_linklists(Bidir_linklists *head);
28 //按位置插
29 int index_inset_linklists(Bidir_linklists *head,int index,datatype num);
30 //按位置删
31 int index_delete_linklists(Bidir_linklists *head,int index);
32 //倒叙遍历
33 void dao_traverse_linklists(Bidir_linklists *head);
34 #endif
扫一扫
631
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
