[已解决]xdm,看看这个为什么报错了

hehexixi

已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。

输入格式:
输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。数字用空格间隔。

输出格式:
在一行中输出合并后新的非降序链表，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NULL。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #define OK 1
   
5. #define ERROR 0
   
6. typedef int Status;
   
7. typedef int ElemType;
   
8. typedef int LinkList;
   
9. typedef struct Node
   
10. {
    
11.         ElemType data;
    
12.         struct Node* next;
    
13. }Node;
    
14. typedef struct Node* LinkList;
    
15. 
    
16. void CreatListHead(LinkList* L)
    
17. {
    
18.         LinkList p;
    
19.         int i;
    
20.         int l;
    
21.         *L = (LinkList)malloc(sizeof(Node));
    
22.         (*L)->next = NULL;
    
23.         scanf("%d", &l);
    
24.         while (l>0)
    
25.         {
    
26.                 p = (LinkList)malloc(sizeof(Node));
    
27.                
    
28.                 p->data = l;
    
29.                 p->next = (*L) ->next;
    
30.                 (*L)->next = p;
    
31.                 scanf("%d", &l);
    
32.         }
    
33. }
    
34. Status ListInsert(LinkList* L, int i, ElemType e)
    
35. {
    
36.         int j;
    
37.         LinkList p, s;
    
38.         p = *L;
    
39.         j = 1;
    
40.         while (p&&j<i)
    
41.         {
    
42.                 p = p->next;
    
43.                 ++j;
    
44.         }
    
45.         if (!p || j > i)
    
46.                 return ERROR;
    
47.         s = (LinkList)malloc(sizeof(Node));
    
48.         s->data = e;
    
49.         s->next = p->next;
    
50.         p->next = s;
    
51.         return OK;
    
52. }
    
53. void pri(LinkList *L)
    
54. {
    
55.         LinkList p, q;
    
56.         p = (LinkList)malloc(sizeof(Node));
    
57.         q = (LinkList)malloc(sizeof(Node));
    
58.         p = *L;
    
59.        
    
60.         if (L)
    
61.         {
    
62.                 q->next;
    
63.                 while (p->next&&q->next)
    
64.                 {
    
65.                         printf("%d", p->data);
    
66.                         p = q;
    
67.                         q = q->next;
    
68.                 }
    
69.                
    
70.         }
    
71.         else
    
72.         {
    
73.                 printf("NULL\n");
    
74.         }
    
75. }
    
76. 
    
77. void merge(LinkList la, LinkList lb, LinkList lc)
    
78. {
    
79.         la = la->next;
    
80.         lb = lb->next;
    
81.         while (la&&lb)
    
82.         {
    
83.                 if (la->data > lb->data)
    
84.                 {
    
85.                         lc->next = lb;
    
86.                         lb = lb->next;
    
87.                 }
    
88.                 else
    
89.                 {
    
90.                         lc->next = la;
    
91.                         la = la->next;
    
92.                 }
    
93.                 lc = lc->next;
    
94.         }
    
95.         if (la)
    
96.         {
    
97.                 lc->next = la;
    
98.         }
    
99.         if (lb)
    
100.         {
     
101.                 lc->next = lb;
     
102.         }
     
103. }
     
104. int main()
     
105. {
     
106.         LinkList la, lb, lc;
     
107.         CreatListHead(la);
     
108.         CreatListHead(lb);
     
109.         CreatListHead(lc);
     
110.         merge(la, lb, lc);
     
111.         pri(lc);
     
112.         return 0;
     
113. }

复制代码

找半天问题了

最佳答案

月排行榜 / 总排行榜

人造人

2021-11-5 15:26:25

跳转到最佳答案楼层

人造人

hehexixi

人造人 发表于 2021-11-5 16:38

hxd,应该怎么改啊，救救孩子吧

monkey-D

先不说逻辑上的错误，代码本身有问题，建议还是对着书本或者网站的样例比对一下。

人造人

hehexixi 发表于 2021-11-5 17:13
hxd,应该怎么改啊，救救孩子吧

你这代码写的真的没法改
把你这个代码改能用了，基本上这个代码就看不出是你写的了，需要的话，我给你重写一个
简单来说就是，改这个代码不如重写一个

人造人

等一等，我给你重写一个

hehexixi

monkey-D 发表于 2021-11-5 17:43
先不说逻辑上的错误，代码本身有问题，建议还是对着书本或者网站的样例比对一下。

就按照甲鱼老师数据结构打的

人造人

hehexixi 发表于 2021-11-5 18:43
就按照甲鱼老师数据结构打的

人造人

1. 不要把所有的代码都写到一个文件中，这样不方便修改，不方便阅读
2. 申请了内存要释放，你为什么不写释放内存的代码？
释放内存，这么重要的操作你居然完全忽略？
3. 你的代码还有很多其他问题，我没有一个一个去看

list.h

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

复制代码

list.c

1. #include "list.h"
   
2. #include <stdlib.h>
   
3. #include <memory.h>
   
4. 
   
5. list_t *list_init(void) {
   
6.     list_t *list = malloc(sizeof(*list));
   
7.     if(!list) return NULL;
   
8.     list->head = NULL;
   
9.     list->size = 0;
   
10.     return list;
    
11. }
    
12. 
    
13. void list_deinit(list_t *list) {
    
14.     if(!list) return;
    
15.     list_clean(list);
    
16.     free(list);
    
17. }
    
18. 
    
19. bool list_clean(list_t *list) {
    
20.     if(!list) return false;
    
21.     while(!list_empty(list)) list_delete(list, 0);
    
22.     return true;
    
23. }
    
24. 
    
25. bool list_insert(list_t *list, size_t index, void *data, size_t size) {
    
26.     if(!list) return false;
    
27.     if(list_size(list) < index) return false;
    
28.     if(!data) return false;
    
29.     struct list_node_tag **current = &list->head;
    
30.     while(index--) current = &(*current)->next;
    
31.     struct list_node_tag *node = malloc(sizeof(*node));
    
32.     if(!node) return false;
    
33.     node->data = malloc(size);
    
34.     if(!node->data) {free(node); return false;}
    
35.     memcpy(node->data, data, size);
    
36.     node->size = size;
    
37.     node->next = *current;
    
38.     *current = node;
    
39.     ++list->size;
    
40.     return true;
    
41. }
    
42. 
    
43. bool list_delete(list_t *list, size_t index) {
    
44.     if(!list) return false;
    
45.     if(list_size(list) <= index) return false;
    
46.     struct list_node_tag **current = &list->head;
    
47.     while(index--) current = &(*current)->next;
    
48.     struct list_node_tag *temp = *current;
    
49.     *current = temp->next;
    
50.     free(temp->data); free(temp);
    
51.     --list->size;
    
52.     return true;
    
53. }
    
54. 
    
55. bool list_get(const list_t *list, size_t index, void *data, size_t size) {
    
56.     if(!list) return false;
    
57.     if(list_size(list) <= index) return false;
    
58.     if(!data) return false;
    
59.     struct list_node_tag *const *current = &list->head;
    
60.     while(index--) current = &(*current)->next;
    
61.     struct list_node_tag *temp = *current;
    
62.     if(temp->size > size) return false;
    
63.     memcpy(data, temp->data, size);
    
64.     return true;
    
65. }
    
66. 
    
67. bool list_append(list_t *list, void *data, size_t size) {
    
68.     if(!list) return false;
    
69.     return list_insert(list, list_size(list), data, size);
    
70. }
    
71. 
    
72. size_t list_size(const list_t *list) {
    
73.     if(!list) return 0;
    
74.     return list->size;
    
75. }
    
76. 
    
77. bool list_empty(const list_t *list) {
    
78.     if(!list) return 0;
    
79.     return list_size(list) == 0;
    
80. }
    

复制代码

main.c

1. #include "list.h"
   
2. #include <stdio.h>
   
3. 
   
4. void read_number(list_t *list) {
   
5.     while(1) {
   
6.         size_t n; scanf("%lu", &n);
   
7.         if(n == 0) break;
   
8.         list_append(list, &n, sizeof(n));
   
9.     }
   
10. }
    
11. 
    
12. list_t *list_merge(const list_t *a, const list_t *b) {
    
13.     size_t i = 0, j = 0;
    
14.     list_t *list = list_init();
    
15.     while(i < list_size(a) && j < list_size(b)) {
    
16.         size_t m, n;
    
17.         list_get(a, i, &m, sizeof(m));
    
18.         list_get(b, j, &n, sizeof(n));
    
19.         if(m < n) {
    
20.             list_append(list, &m, sizeof(m));
    
21.             ++i;
    
22.         } else {
    
23.             list_append(list, &n, sizeof(n));
    
24.             ++j;
    
25.         }
    
26.     }
    
27.     while(i < list_size(a)) {
    
28.         size_t m;
    
29.         list_get(a, i, &m, sizeof(m));
    
30.         list_append(list, &m, sizeof(m));
    
31.         ++i;
    
32.     }
    
33.     while(j < list_size(b)) {
    
34.         size_t n;
    
35.         list_get(b, j, &n, sizeof(n));
    
36.         list_append(list, &n, sizeof(n));
    
37.         ++j;
    
38.     }
    
39.     return list;
    
40. }
    
41. 
    
42. void list_output(const list_t *list) {
    
43.     const char *sep = "";
    
44.     for(size_t i = 0; i < list_size(list); ++i) {
    
45.         size_t temp; list_get(list, i, &temp, sizeof(temp));
    
46.         printf("%s%lu", sep, temp); sep = " ";
    
47.     }
    
48.     printf("\n");
    
49. }
    
50. 
    
51. int main(void) {
    
52.     list_t *s1 = list_init();
    
53.     list_t *s2 = list_init();
    
54.     read_number(s1);
    
55.     read_number(s2);
    
56.     list_t *s3 = list_merge(s1, s2);
    
57.     list_output(s3);
    
58.     list_deinit(s3);
    
59.     list_deinit(s2);
    
60.     list_deinit(s1);
    
61.     return 0;
    
62. }
    

复制代码

hehexixi

人造人 发表于 2021-11-5 20:58
1. 不要把所有的代码都写到一个文件中，这样不方便修改，不方便阅读
2. 申请了内存要释放，你为什么不写释 ...

谢了大兄弟