求大神帮忙编程完成合并两循环单链表

猫喵鱼

用c语言

人造人

估计你要的是单向循环链表，但是因为我不认真看题，我写完了双向循环链表后才发现这个问题
不管怎么说，双向循环链表也是循环链表
参考下面的这个代码自己完成单向循环链表吧

list.h

1. #ifndef _LIST_H_
   
2. #define _LIST_H_
   
3. 
   
4. #include <stddef.h>
   
5. #include <stdbool.h>
   
6. 
   
7. typedef struct list_node_tag {
   
8.     struct list_node_tag *prev;
   
9.     struct list_node_tag *next;
   
10.     void *data;
    
11.     size_t size;
    
12. } list_node_t;
    
13. 
    
14. typedef struct {
    
15.     list_node_t *node;
    
16.     size_t size;
    
17. } list_t;
    
18. 
    
19. list_t *list_init(void);
    
20. void list_deinit(list_t *list);
    
21. void list_clean(list_t *list);
    
22. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
23. bool list_delete(list_t *list, size_t index);
    
24. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
25. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
26. bool list_append(list_t *list, const void *data, size_t size);
    
27. bool list_empty(const list_t *list);
    
28. size_t list_size(const list_t *list);
    
29. 
    
30. list_t *list_union(const list_t *a, const list_t *b);
    
31. 
    
32. #endif
    

复制代码

list.c

1. #include "list.h"
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. #define GET_NODE(list, index) ({ \
   
6.         const list_t *this_list = list; \
   
7.         size_t this_index = (index) + 1; \
   
8.         list_node_t *node = this_list->node; \
   
9.         while(this_index--) node = node->next; \
   
10.         node; \
    
11.     })
    
12. 
    
13. static list_node_t *new_node(size_t size) {
    
14.     list_node_t *node = malloc(sizeof(*node));
    
15.     if(!node) return node;
    
16.     node->data = malloc(size);
    
17.     if(size && !node->data) {free(node); return NULL;}
    
18.     node->size = size;
    
19.     node->next = node;
    
20.     node->prev = node;
    
21.     return node;
    
22. }
    
23. 
    
24. static void delete_node(list_node_t *node) {
    
25.     if(!node) return;
    
26.     free(node->data);
    
27.     free(node);
    
28. }
    
29. 
    
30. list_t *list_init(void) {
    
31.     list_t *list = malloc(sizeof(*list));
    
32.     if(!list) return list;
    
33.     list->node = new_node(0);
    
34.     if(!list->node) {free(list); return NULL;}
    
35.     list->size = 0;
    
36.     return list;
    
37. }
    
38. 
    
39. void list_deinit(list_t *list) {
    
40.     if(!list) return;
    
41.     list_clean(list);
    
42.     delete_node(list->node);
    
43.     free(list);
    
44. }
    
45. 
    
46. void list_clean(list_t *list) {
    
47.     if(!list) return;
    
48.     while(!list_empty(list)) list_delete(list, 0);
    
49. }
    
50. 
    
51. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
    
52.     if(!list) return false;
    
53.     if(index > list_size(list)) return false;
    
54.     list_node_t *node = new_node(size);
    
55.     if(!node) return false;
    
56.     memcpy(node->data, data, node->size);
    
57.     list_node_t *current = list->node;
    
58.     while(index--) current = current->next;
    
59.     node->next = current->next;
    
60.     node->prev = current;
    
61.     current->next = node;
    
62.     node->next->prev = node;
    
63.     ++list->size;
    
64.     return true;
    
65. }
    
66. 
    
67. bool list_delete(list_t *list, size_t index) {
    
68.     if(!list) return false;
    
69.     if(index >= list_size(list)) return false;
    
70.     list_node_t *current = list->node;
    
71.     while(index--) current = current->next;
    
72.     list_node_t *temp = current->next;
    
73.     current->next = temp->next;
    
74.     temp->next->prev = current;
    
75.     delete_node(temp);
    
76.     --list->size;
    
77.     return true;
    
78. }
    
79. 
    
80. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
    
81.     if(!list) return false;
    
82.     bool res = list_delete(list, index);
    
83.     if(!res) return res;
    
84.     return list_insert(list, index, data, size);
    
85. }
    
86. 
    
87. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
    
88.     if(!list) return false;
    
89.     if(index >= list_size(list)) return false;
    
90.     list_node_t *current = GET_NODE(list, index);
    
91.     if(!data) return false;
    
92.     if(size < current->size) return false;
    
93.     memcpy(data, current->data, current->size);
    
94.     return true;
    
95. }
    
96. 
    
97. bool list_append(list_t *list, const void *data, size_t size) {
    
98.     if(!list) return false;
    
99.     return list_insert(list, list_size(list), data, size);
    
100. }
     
101. 
     
102. bool list_empty(const list_t *list) {
     
103.     if(!list) return true;
     
104.     return list->size == 0;
     
105. }
     
106. 
     
107. size_t list_size(const list_t *list) {
     
108.     if(!list) return 0;
     
109.     return list->size;
     
110. }
     
111. 
     
112. list_t *list_union(const list_t *a, const list_t *b) {
     
113.     list_t *list = list_init();
     
114.     for(size_t i = 0; i < list_size(a); ++i) {
     
115.         list_node_t *current = GET_NODE(a, i);
     
116.         list_append(list, current->data, current->size);
     
117.     }
     
118.     for(size_t i = 0; i < list_size(b); ++i) {
     
119.         list_node_t *current = GET_NODE(b, i);
     
120.         list_append(list, current->data, current->size);
     
121.     }
     
122.     return list;
     
123. }
     

复制代码

main.c

1. #include "list.h"
   
2. #include <stdio.h>
   
3. 
   
4. typedef struct {
   
5.     char c;
   
6.     int i;
   
7.     double d;
   
8. } test_t;
   
9. 
   
10. int main(void) {
    
11.     list_t *list = list_init();
    
12.     {
    
13.         test_t t = {'x', 123, 3.14};
    
14.         list_append(list, &t.c, sizeof(t.c));
    
15.         list_append(list, &t.i, sizeof(t.i));
    
16.         list_append(list, &t.d, sizeof(t.d));
    
17.         list_append(list, &t, sizeof(t));
    
18.     }
    
19.     {
    
20.         test_t t;
    
21.         list_get(list, 0, &t.c, sizeof(t.c));
    
22.         list_get(list, 1, &t.i, sizeof(t.i));
    
23.         list_get(list, 2, &t.d, sizeof(t.d));
    
24.         printf("%c %d %lf\n", t.c, t.i, t.d);
    
25.     }
    
26.     {
    
27.         test_t t;
    
28.         list_get(list, 3, &t, sizeof(t));
    
29.         printf("%c %d %lf\n", t.c, t.i, t.d);
    
30.     }
    
31.     {
    
32.         double d;
    
33.         list_delete(list, 1);
    
34.         list_get(list, 1, &d, sizeof(d));
    
35.         printf("%lf\n", d);
    
36.     }
    
37.     {
    
38.         char c;
    
39.         list_delete(list, 1);
    
40.         list_get(list, 0, &c, sizeof(c));
    
41.         printf("%c\n", c);
    
42.     }
    
43.     {
    
44.         list_delete(list, 1);
    
45.         list_delete(list, 0);
    
46.         for(size_t i = 0; i < 10; ++i) {
    
47.             list_append(list, &i, sizeof(i));
    
48.         }
    
49.     }
    
50.     {
    
51.         size_t i;
    
52.         list_get(list, 9, &i, sizeof(i));
    
53.         printf("%lu\n", i);
    
54.     }
    
55.     list_deinit(list);
    
56.     {
    
57.         list_t *a = list_init();
    
58.         list_t *b = list_init();
    
59.         for(size_t i = 0; i < 10; ++i) {
    
60.             list_append(a, &i, sizeof(i));
    
61.         }
    
62.         for(size_t i = 100; i < 107; ++i) {
    
63.             list_append(b, &i, sizeof(i));
    
64.         }
    
65.         list_t *c = list_union(a, b);
    
66.         for(size_t i = 0; i < list_size(c); ++i) {
    
67.             size_t value;
    
68.             list_get(c, i, &value, sizeof(value));
    
69.             printf("%lu ", value);
    
70.         }
    
71.         puts("");
    
72.         list_deinit(c);
    
73.         list_deinit(b);
    
74.         list_deinit(a);
    
75.     }
    
76.     return 0;
    
77. }
    

复制代码

1. $ gcc-debug -o main main.c list.c
   
2. $ ./main
   
3. x 123 3.140000
   
4. x 123 3.140000
   
5. 3.140000
   
6. x
   
7. 9
   
8. 0 1 2 3 4 5 6 7 8 9 100 101 102 103 104 105 106
   
9. $

复制代码

傻眼貓咪

来学习学习

人造人

单向循环链表

list.h

1. #ifndef _LIST_H_
   
2. #define _LIST_H_
   
3. 
   
4. #include <stddef.h>
   
5. #include <stdbool.h>
   
6. 
   
7. typedef struct list_node_tag {
   
8.     struct list_node_tag *next;
   
9.     void *data;
   
10.     size_t size;
    
11. } list_node_t;
    
12. 
    
13. typedef struct {
    
14.     list_node_t *node;
    
15.     size_t size;
    
16. } list_t;
    
17. 
    
18. list_t *list_init(void);
    
19. void list_deinit(list_t *list);
    
20. void list_clean(list_t *list);
    
21. bool list_insert(list_t *list, size_t index, const void *data, size_t size);
    
22. bool list_delete(list_t *list, size_t index);
    
23. bool list_set(list_t *list, size_t index, const void *data, size_t size);
    
24. bool list_get(const list_t *list, size_t index, void *data, size_t size);
    
25. bool list_append(list_t *list, const void *data, size_t size);
    
26. bool list_empty(const list_t *list);
    
27. size_t list_size(const list_t *list);
    
28. 
    
29. list_t *list_union(const list_t *a, const list_t *b);
    
30. 
    
31. #endif
    

复制代码

list.c

1. #include "list.h"
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. #define GET_NODE(list, index) ({ \
   
6.         const list_t *this_list = list; \
   
7.         size_t this_index = (index) + 1; \
   
8.         list_node_t *node = this_list->node; \
   
9.         while(this_index--) node = node->next; \
   
10.         node; \
    
11.     })
    
12. 
    
13. static list_node_t *new_node(size_t size) {
    
14.     list_node_t *node = malloc(sizeof(*node));
    
15.     if(!node) return node;
    
16.     node->data = malloc(size);
    
17.     if(size && !node->data) {free(node); return NULL;}
    
18.     node->size = size;
    
19.     node->next = node;
    
20.     return node;
    
21. }
    
22. 
    
23. static void delete_node(list_node_t *node) {
    
24.     if(!node) return;
    
25.     free(node->data);
    
26.     free(node);
    
27. }
    
28. 
    
29. list_t *list_init(void) {
    
30.     list_t *list = malloc(sizeof(*list));
    
31.     if(!list) return list;
    
32.     list->node = new_node(0);
    
33.     if(!list->node) {free(list); return NULL;}
    
34.     list->size = 0;
    
35.     return list;
    
36. }
    
37. 
    
38. void list_deinit(list_t *list) {
    
39.     if(!list) return;
    
40.     list_clean(list);
    
41.     delete_node(list->node);
    
42.     free(list);
    
43. }
    
44. 
    
45. void list_clean(list_t *list) {
    
46.     if(!list) return;
    
47.     while(!list_empty(list)) list_delete(list, 0);
    
48. }
    
49. 
    
50. bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
    
51.     if(!list) return false;
    
52.     if(index > list_size(list)) return false;
    
53.     list_node_t *node = new_node(size);
    
54.     if(!node) return false;
    
55.     memcpy(node->data, data, node->size);
    
56.     list_node_t *current = list->node;
    
57.     while(index--) current = current->next;
    
58.     node->next = current->next;
    
59.     current->next = node;
    
60.     ++list->size;
    
61.     return true;
    
62. }
    
63. 
    
64. bool list_delete(list_t *list, size_t index) {
    
65.     if(!list) return false;
    
66.     if(index >= list_size(list)) return false;
    
67.     list_node_t *current = list->node;
    
68.     while(index--) current = current->next;
    
69.     list_node_t *temp = current->next;
    
70.     current->next = temp->next;
    
71.     delete_node(temp);
    
72.     --list->size;
    
73.     return true;
    
74. }
    
75. 
    
76. bool list_set(list_t *list, size_t index, const void *data, size_t size) {
    
77.     if(!list) return false;
    
78.     bool res = list_delete(list, index);
    
79.     if(!res) return res;
    
80.     return list_insert(list, index, data, size);
    
81. }
    
82. 
    
83. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
    
84.     if(!list) return false;
    
85.     if(index >= list_size(list)) return false;
    
86.     list_node_t *current = GET_NODE(list, index);
    
87.     if(!data) return false;
    
88.     if(size < current->size) return false;
    
89.     memcpy(data, current->data, current->size);
    
90.     return true;
    
91. }
    
92. 
    
93. bool list_append(list_t *list, const void *data, size_t size) {
    
94.     if(!list) return false;
    
95.     return list_insert(list, list_size(list), data, size);
    
96. }
    
97. 
    
98. bool list_empty(const list_t *list) {
    
99.     if(!list) return true;
    
100.     return list->size == 0;
     
101. }
     
102. 
     
103. size_t list_size(const list_t *list) {
     
104.     if(!list) return 0;
     
105.     return list->size;
     
106. }
     
107. 
     
108. list_t *list_union(const list_t *a, const list_t *b) {
     
109.     list_t *list = list_init();
     
110.     for(size_t i = 0; i < list_size(a); ++i) {
     
111.         list_node_t *current = GET_NODE(a, i);
     
112.         list_append(list, current->data, current->size);
     
113.     }
     
114.     for(size_t i = 0; i < list_size(b); ++i) {
     
115.         list_node_t *current = GET_NODE(b, i);
     
116.         list_append(list, current->data, current->size);
     
117.     }
     
118.     return list;
     
119. }
     

复制代码

main.c

1. #include "list.h"
   
2. #include <stdio.h>
   
3. 
   
4. typedef struct {
   
5.     char c;
   
6.     int i;
   
7.     double d;
   
8. } test_t;
   
9. 
   
10. int main(void) {
    
11.     list_t *list = list_init();
    
12.     {
    
13.         test_t t = {'x', 123, 3.14};
    
14.         list_append(list, &t.c, sizeof(t.c));
    
15.         list_append(list, &t.i, sizeof(t.i));
    
16.         list_append(list, &t.d, sizeof(t.d));
    
17.         list_append(list, &t, sizeof(t));
    
18.     }
    
19.     {
    
20.         test_t t;
    
21.         list_get(list, 0, &t.c, sizeof(t.c));
    
22.         list_get(list, 1, &t.i, sizeof(t.i));
    
23.         list_get(list, 2, &t.d, sizeof(t.d));
    
24.         printf("%c %d %lf\n", t.c, t.i, t.d);
    
25.     }
    
26.     {
    
27.         test_t t;
    
28.         list_get(list, 3, &t, sizeof(t));
    
29.         printf("%c %d %lf\n", t.c, t.i, t.d);
    
30.     }
    
31.     {
    
32.         double d;
    
33.         list_delete(list, 1);
    
34.         list_get(list, 1, &d, sizeof(d));
    
35.         printf("%lf\n", d);
    
36.     }
    
37.     {
    
38.         char c;
    
39.         list_delete(list, 1);
    
40.         list_get(list, 0, &c, sizeof(c));
    
41.         printf("%c\n", c);
    
42.     }
    
43.     {
    
44.         list_delete(list, 1);
    
45.         list_delete(list, 0);
    
46.         for(size_t i = 0; i < 10; ++i) {
    
47.             list_append(list, &i, sizeof(i));
    
48.         }
    
49.     }
    
50.     {
    
51.         size_t i;
    
52.         list_get(list, 9, &i, sizeof(i));
    
53.         printf("%lu\n", i);
    
54.     }
    
55.     list_deinit(list);
    
56.     {
    
57.         list_t *a = list_init();
    
58.         list_t *b = list_init();
    
59.         for(size_t i = 0; i < 10; ++i) {
    
60.             list_append(a, &i, sizeof(i));
    
61.         }
    
62.         for(size_t i = 100; i < 107; ++i) {
    
63.             list_append(b, &i, sizeof(i));
    
64.         }
    
65.         list_t *c = list_union(a, b);
    
66.         for(size_t i = 0; i < list_size(c); ++i) {
    
67.             size_t value;
    
68.             list_get(c, i, &value, sizeof(value));
    
69.             printf("%lu ", value);
    
70.         }
    
71.         puts("");
    
72.         list_deinit(c);
    
73.         list_deinit(b);
    
74.         list_deinit(a);
    
75.     }
    
76.     return 0;
    
77. }
    

复制代码