用C语言简单实现一个单向链表：

china2022

编写一个程序将一个头结点指针为pa的单链表A分解成两个单链表A和B，其头结点指针分别为pa和pb，使得A链表中含有原链表A中序号为奇数的元素，而链表B中含有原链表A中序号为偶数的元素，且保持原来的相对顺序。

人造人

题目什么意思？
意思是一开始有一个链表a
执行了一段代码后又生成了一个链表b
链表a里面是奇数，链表b里面是偶数
是这样吗？

没有完完全全按照题目要求来写代码
如果你是为了交作业的话，你可以参考这个代码写一个你自己的版本
如果你是为了学习的话，这个代码中有好多你需要学习的东西

1. $ ls
   
2. list.c  list.h  main.c
   
3. $ cat main.c
   
4. #include "list.h"
   
5. #include <stdio.h>
   
6. 
   
7. void output(const list_t *list, size_t index) {
   
8.     if(index >= list_size(list)) return;
   
9.     size_t temp; list_get(list, index, &temp, sizeof(temp));
   
10.     printf("%zd ", temp);
    
11.     output(list, index + 1);
    
12. }
    
13. 
    
14. int main(void) {
    
15.     list_t *a = list_init();
    
16.     list_t *b = list_init();
    
17.     for(size_t i = 0; i < 10; ++i) {
    
18.         list_append(a, &i, sizeof(i));
    
19.     }
    
20.     printf("a: "); output(a, 0); puts("");
    
21.     // 这里要在同一个循环中删除同一个链表中的很多元素
    
22.     // 那就只能是倒着遍历这个链表了
    
23.     for(ssize_t i = list_size(a) - 1; i >= 0; --i) {
    
24.         if(i % 2 != 0) continue;
    
25.         size_t temp; list_get(a, i, &temp, sizeof(temp));
    
26.         list_delete(a, i);
    
27.         list_insert(b, 0, &temp, sizeof(temp));
    
28.     }
    
29.     printf("a: "); output(a, 0); puts("");
    
30.     printf("b: "); output(b, 0); puts("");
    
31.     list_deinit(b);
    
32.     list_deinit(a);
    
33.     return 0;
    
34. }
    
35. $ cat list.h
    
36. #ifndef _LIST_H_
    
37. #define _LIST_H_
    
38. 
    
39. #include <stddef.h>
    
40. #include <stdbool.h>
    
41. 
    
42. struct list_node_tag {
    
43.     void *data; size_t size;
    
44.     struct list_node_tag *next;
    
45. };
    
46. 
    
47. typedef struct {
    
48.     struct list_node_tag *head;
    
49.     size_t size;
    
50. } list_t;
    
51. 
    
52. list_t *list_init(void);
    
53. void list_deinit(list_t *list);
    
54. bool list_clean(list_t *list);
    
55. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
56. bool list_delete(list_t *list, size_t index);
    
57. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
58. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
59. bool list_append(list_t *list, const void *data, size_t size);
    
60. size_t list_size(const list_t *list);
    
61. bool list_empty(const list_t *list);
    
62. 
    
63. #endif
    
64. $ cat list.c
    
65. #include "list.h"
    
66. #include <stdlib.h>
    
67. #include <memory.h>
    
68. 
    
69. list_t *list_init(void) {
    
70.     list_t *list = malloc(sizeof(*list));
    
71.     if(!list) return NULL;
    
72.     list->head = NULL;
    
73.     list->size = 0;
    
74.     return list;
    
75. }
    
76. 
    
77. void list_deinit(list_t *list) {
    
78.     if(!list) return;
    
79.     list_clean(list);
    
80.     free(list);
    
81. }
    
82. 
    
83. bool list_clean(list_t *list) {
    
84.     if(!list) return false;
    
85.     while(!list_empty(list)) list_delete(list, 0);
    
86.     return true;
    
87. }
    
88. 
    
89. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
    
90.     if(!list) return false;
    
91.     if(list_size(list) < index) return false;
    
92.     if(!data) return false;
    
93.     struct list_node_tag **current = &list->head;
    
94.     while(index--) current = &(*current)->next;
    
95.     struct list_node_tag *node = malloc(sizeof(*node));
    
96.     if(!node) return false;
    
97.     node->data = malloc(size);
    
98.     if(!node->data) {free(node); return false;}
    
99.     memcpy(node->data, data, size);
    
100.     node->size = size;
     
101.     node->next = *current;
     
102.     *current = node;
     
103.     ++list->size;
     
104.     return true;
     
105. }
     
106. 
     
107. bool list_delete(list_t *list, size_t index) {
     
108.     if(!list) return false;
     
109.     if(list_size(list) <= index) return false;
     
110.     struct list_node_tag **current = &list->head;
     
111.     while(index--) current = &(*current)->next;
     
112.     struct list_node_tag *temp = *current;
     
113.     *current = temp->next;
     
114.     free(temp->data); free(temp);
     
115.     --list->size;
     
116.     return true;
     
117. }
     
118. 
     
119. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
     
120.     if(!list) return false;
     
121.     if(list_size(list) <= index) return false;
     
122.     if(!data) return false;
     
123.     struct list_node_tag *const *current = &list->head;
     
124.     while(index--) current = &(*current)->next;
     
125.     struct list_node_tag *temp = *current;
     
126.     if(temp->size > size) return false;
     
127.     memcpy(data, temp->data, temp->size);
     
128.     return true;
     
129. }
     
130. 
     
131. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
     
132.     bool res = list_delete(list, index);
     
133.     return res ? list_insert(list, index, data, size) : res;
     
134. }
     
135. 
     
136. bool list_append(list_t *list, const void *data, size_t size) {
     
137.     if(!list) return false;
     
138.     return list_insert(list, list_size(list), data, size);
     
139. }
     
140. 
     
141. size_t list_size(const list_t *list) {
     
142.     if(!list) return 0;
     
143.     return list->size;
     
144. }
     
145. 
     
146. bool list_empty(const list_t *list) {
     
147.     if(!list) return true;
     
148.     return list_size(list) == 0;
     
149. }
     
150. $ gcc -g -Wall -o main main.c list.c
     
151. $ ls
     
152. list.c  list.h  main  main.c
     
153. $ ./main
     
154. a: 0 1 2 3 4 5 6 7 8 9
     
155. a: 1 3 5 7 9
     
156. b: 0 2 4 6 8
     
157. $
     

复制代码