[已解决]为什么这里会报错？

1613551

请问为什么会这样报错啊？

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #define MaxSize 50
   
4. typedef int ElemType; // 把int替换成了Elemtype
   
5. typedef struct LinkList
   
6. {
   
7.     ElemType elem;                                        // 存储整形元素
   
8.     struct LinkList *next;                                // 指向直接后继元素的指针
   
9. } LinkList;                                               // 等同于用typedef把struct LinkList定义成Linklist就不需要再输入struct LinkList，可以直接输入LinkList
   
10. void InitList(LinkList *L);                               // 初始化链表声明
    
11. void CreateList(LinkList *L, ElemType a[], ElemType n);   // 创建链表声明
    
12. ElemType ListInsert(LinkList *L, ElemType i, ElemType e); // 链表插入声明
    
13. ElemType ListDelete(LinkList *L, ElemType i);             // 删除链表声明
    
14. void printlist(LinkList *headpoint);                      // 打印输出表中元素
    
15. int main(void)
    
16. {
    
17.     LinkList head;                                                                                                     // 头结点
    
18.     LinkList *headpoint = &head;                                                                                       // 指向头结点的指针（结构体变量并不指向结构体，所以需要声明结构体指针）
    
19.     ElemType elements[MaxSize], n = 0, insertposition1, insertvalue1, insertposition2, insertvalue2, delete1, delete2; //
    
20.     InitList(headpoint);
    
21.     printf("##创建链表##\n\n");
    
22.     printf("请输入链表中元素值，以空格分隔(如，从键盘上依次输入21 18 30 75 42 56)：");
    
23.     for (int i = 0; i < MaxSize; i++)
    
24.     {
    
25.         scanf("%d", &elements[i]);
    
26.         n++;
    
27.         if (getchar() == '\n')
    
28.         {
    
29.             break;
    
30.         }
    
31.     }
    
32.     CreateList(headpoint, elements, n);
    
33.     printlist(headpoint); // 输出各元素的值
    
34.     putchar('\n');
    
35.     printf(
    
36.         "\n##插入操作##\n\n"
    
37.         "请输入第一次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:");
    
38.     scanf("%d %d", &insertposition1, &insertvalue1);
    
39.     if (ListInsert(headpoint, insertposition1, insertvalue1))
    
40.     {
    
41.         printf("在第%d个位置插入%d成功\n", insertposition1, insertvalue1);
    
42.     }
    
43.     else
    
44.     {
    
45.         printf("在第%d个位置插入%d失败，插入位置不合法\n", insertposition1, insertvalue1);
    
46.     }
    
47.     printlist(headpoint);
    
48.     putchar('\n');
    
49.     printf(
    
50.         "请输入第二次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:");
    
51.     scanf("%d %d", &insertposition2, &insertvalue2);
    
52.     if (ListInsert(headpoint, insertposition2, insertvalue2))
    
53.     {
    
54.         printf("在第%d个位置插入%d成功\n", insertposition2, insertvalue2);
    
55.     }
    
56.     else
    
57.     {
    
58.         printf("在第%d个位置插入%d失败，插入位置不合法\n", insertposition2, insertvalue2);
    
59.     }
    
60.     printlist(headpoint);
    
61.     putchar('\n');
    
62.     printf(
    
63.         "\n##删除操作##\n\n"
    
64.         "请输入第一次要删除元素的位置（如 2 表示删除第2个位置的数值）:");
    
65.     scanf("%d", &delete1);
    
66.     if (ListDelete(headpoint, delete1))
    
67.     {
    
68.         printf("删除第%d个数据元素成功\n", delete1);
    
69.     }
    
70.     else
    
71.     {
    
72.         printf("删除第%d个数据元素失败，删除位置不合法\n", delete1);
    
73.     }
    
74.     printlist(headpoint);
    
75.     putchar('\n');
    
76.     printf(
    
77.         "\n请输入第二次要删除元素的位置（如 2 表示删除第2个位置的数值）:");
    
78.     scanf("%d", &delete2);
    
79.     if (ListDelete(headpoint, delete2))
    
80.     {
    
81.         printf("删除第%d个数据元素成功\n", delete2);
    
82.     }
    
83.     else
    
84.     {
    
85.         printf("删除第%d个数据元素失败,删除位置不合法\n", delete2);
    
86.     }
    
87.     printlist(headpoint);
    
88.     putchar('\n');
    
89.     while (headpoint != NULL) // 为了防止内存泄漏，最后进行内存释放
    
90.     {
    
91.         LinkList *temp = headpoint;
    
92.         headpoint = headpoint->next;
    
93.         free(temp);
    
94.     }
    
95. 
    
96.     printf("\n=====顺序表初始化、插入，删除等操作已完成，程序结束！=====\n\n");
    
97.     system("pause");
    
98.     return 0;
    
99. }
    
100. void InitList(LinkList *L) /* 初始化链表 */
     
101. {
     
102.     L = (struct LinkList *)malloc(sizeof(struct LinkList *));
     
103.     L->next = NULL;
     
104. }
     
105. void CreateList(LinkList *L, ElemType a[], int n) /*创建链表 */
     
106. {
     
107.     LinkList *pre = L;
     
108.     int i;
     
109.     for (i = n - 1; i >= 0; i--)
     
110.     {
     
111.         LinkList *t = (struct LinkList *)malloc(sizeof(struct LinkList *));
     
112.         t->elem = a[i];
     
113.         t->next = NULL;
     
114.         pre->next = t;
     
115.         pre = pre->next;
     
116.     }
     
117. }
     
118. int ListInsert(LinkList *L, int i, ElemType e) /*按i位置插入元素*/
     
119. {
     
120. 
     
121.     int j = 0;
     
122.     LinkList *p = L;
     
123.     while (p && (j < i - 1))
     
124.     {
     
125.         p = p->next;
     
126.         j++;
     
127.     }
     
128.     if (!p || (j > i - 1))
     
129.         return 0;
     
130.     LinkList *t = (struct LinkList *)malloc(sizeof(struct LinkList *));
     
131.     t->elem = e;
     
132.     t->next = p->next;
     
133.     p->next = t;
     
134.     return 1;
     
135. }
     
136. int ListDelete(LinkList *L, int i) /*删除某个位置的元素*/
     
137. {
     
138.     int j = 0;
     
139.     LinkList *p = L;
     
140.     LinkList *del = NULL;
     
141.     while ((p->next) && (j < i - 1))
     
142.     {
     
143.         p = p->next;
     
144.         j++;
     
145.     }
     
146.     if (!(p->next) || (j > i - 1))
     
147.     {
     
148.         return 0;
     
149.     }
     
150.     del = p->next;
     
151.     p->next = del->next;
     
152. 
     
153.     free(del);
     
154.     return 1;
     
155. }
     
156. void printlist(LinkList *headpoint) // 打印输出表中元素
     
157. {
     
158.     printf("\n当前表中元素如下\n");
     
159.     LinkList *p = headpoint->next;
     
160.     putchar('{');
     
161.     while (p != NULL)
     
162.     {
     
163.         printf("%d ", p->elem);
     
164.         p = p->next;
     
165.     }
     
166.     putchar('}');
     
167. }

复制代码

最佳答案

月排行榜 / 总排行榜

额外减小

2023-10-15 20:09:33

我知道了。
请你看一下代码的第18行：

1. LinkList *headpoint = &head;

复制代码

可以发现，这里的 headpoint 变量并不是用 malloc 动态申请的内存空间指针，而是一个静态的指针。所以是不能被 free 函数删除的。

所以只需删除 headpoint 指向的一系列动态内存空间即可。

修改后的代码（仅修改主函数最后几句）

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #define MaxSize 50
   
4. typedef int ElemType; // 把int替换成了Elemtype
   
5. typedef struct LinkList
   
6. {
   
7.     ElemType elem;                                        // 存储整形元素
   
8.     struct LinkList *next;                                // 指向直接后继元素的指针
   
9. } LinkList;                                               // 等同于用typedef把struct LinkList定义成Linklist就不需要再输入struct LinkList，可以直接输入LinkList
   
10. void InitList(LinkList *L);                               // 初始化链表声明
    
11. void CreateList(LinkList *L, ElemType a[], ElemType n);   // 创建链表声明
    
12. ElemType ListInsert(LinkList *L, ElemType i, ElemType e); // 链表插入声明
    
13. ElemType ListDelete(LinkList *L, ElemType i);             // 删除链表声明
    
14. void printlist(LinkList *headpoint);                      // 打印输出表中元素
    
15. int main(void)
    
16. {
    
17.     LinkList head;                                                                                                     // 头结点
    
18.     LinkList *headpoint = &head;                                                                                       // 指向头结点的指针（结构体变量并不指向结构体，所以需要声明结构体指针）
    
19.     ElemType elements[MaxSize], n = 0, insertposition1, insertvalue1, insertposition2, insertvalue2, delete1, delete2; //
    
20.     InitList(headpoint);
    
21.     printf("##创建链表##\n\n");
    
22.     printf("请输入链表中元素值，以空格分隔(如，从键盘上依次输入21 18 30 75 42 56)：");
    
23.     for (int i = 0; i < MaxSize; i++)
    
24.     {
    
25.         scanf("%d", &elements[i]);
    
26.         n++;
    
27.         if (getchar() == '\n')
    
28.         {
    
29.             break;
    
30.         }
    
31.     }
    
32.     CreateList(headpoint, elements, n);
    
33.     printlist(headpoint); // 输出各元素的值
    
34.     putchar('\n');
    
35.     printf(
    
36.         "\n##插入操作##\n\n"
    
37.         "请输入第一次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:");
    
38.     scanf("%d %d", &insertposition1, &insertvalue1);
    
39.     if (ListInsert(headpoint, insertposition1, insertvalue1))
    
40.     {
    
41.         printf("在第%d个位置插入%d成功\n", insertposition1, insertvalue1);
    
42.     }
    
43.     else
    
44.     {
    
45.         printf("在第%d个位置插入%d失败，插入位置不合法\n", insertposition1, insertvalue1);
    
46.     }
    
47.     printlist(headpoint);
    
48.     putchar('\n');
    
49.     printf(
    
50.         "请输入第二次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:");
    
51.     scanf("%d %d", &insertposition2, &insertvalue2);
    
52.     if (ListInsert(headpoint, insertposition2, insertvalue2))
    
53.     {
    
54.         printf("在第%d个位置插入%d成功\n", insertposition2, insertvalue2);
    
55.     }
    
56.     else
    
57.     {
    
58.         printf("在第%d个位置插入%d失败，插入位置不合法\n", insertposition2, insertvalue2);
    
59.     }
    
60.     printlist(headpoint);
    
61.     putchar('\n');
    
62.     printf(
    
63.         "\n##删除操作##\n\n"
    
64.         "请输入第一次要删除元素的位置（如 2 表示删除第2个位置的数值）:");
    
65.     scanf("%d", &delete1);
    
66.     if (ListDelete(headpoint, delete1))
    
67.     {
    
68.         printf("删除第%d个数据元素成功\n", delete1);
    
69.     }
    
70.     else
    
71.     {
    
72.         printf("删除第%d个数据元素失败，删除位置不合法\n", delete1);
    
73.     }
    
74.     printlist(headpoint);
    
75.     putchar('\n');
    
76.     printf(
    
77.         "\n请输入第二次要删除元素的位置（如 2 表示删除第2个位置的数值）:");
    
78.     scanf("%d", &delete2);
    
79.     if (ListDelete(headpoint, delete2))
    
80.     {
    
81.         printf("删除第%d个数据元素成功\n", delete2);
    
82.     }
    
83.     else
    
84.     {
    
85.         printf("删除第%d个数据元素失败,删除位置不合法\n", delete2);
    
86.     }
    
87.     printlist(headpoint);
    
88.     putchar('\n');
    
89.     headpoint=headpoint->next;
    
90.     while (headpoint != NULL) // 为了防止内存泄漏，最后进行内存释放
    
91.     {
    
92.         LinkList *temp = headpoint;
    
93.         
    
94.         headpoint = headpoint->next;
    
95.         
    
96.         free(temp);
    
97.         
    
98.     }
    
99. 
    
100.     printf("\n=====顺序表初始化、插入，删除等操作已完成，程序结束！=====\n\n");
     
101.     system("pause");
     
102.     return 0;
     
103. }
     
104. void InitList(LinkList *L) /* 初始化链表 */
     
105. {
     
106.     L = (struct LinkList *)malloc(sizeof(struct LinkList *));
     
107.     L->next = NULL;
     
108. }
     
109. void CreateList(LinkList *L, ElemType a[], int n) /*创建链表 */
     
110. {
     
111.     LinkList *pre = L;
     
112.     int i;
     
113.     for (i = n - 1; i >= 0; i--)
     
114.     {
     
115.         LinkList *t = (struct LinkList *)malloc(sizeof(struct LinkList *));
     
116.         t->elem = a[i];
     
117.         t->next = NULL;
     
118.         pre->next = t;
     
119.         pre = pre->next;
     
120.     }
     
121. }
     
122. int ListInsert(LinkList *L, int i, ElemType e) /*按i位置插入元素*/
     
123. {
     
124. 
     
125.     int j = 0;
     
126.     LinkList *p = L;
     
127.     while (p && (j < i - 1))
     
128.     {
     
129.         p = p->next;
     
130.         j++;
     
131.     }
     
132.     if (!p || (j > i - 1))
     
133.         return 0;
     
134.     LinkList *t = (struct LinkList *)malloc(sizeof(struct LinkList *));
     
135.     t->elem = e;
     
136.     t->next = p->next;
     
137.     p->next = t;
     
138.     return 1;
     
139. }
     
140. int ListDelete(LinkList *L, int i) /*删除某个位置的元素*/
     
141. {
     
142.     int j = 0;
     
143.     LinkList *p = L;
     
144.     LinkList *del = NULL;
     
145.     while ((p->next) && (j < i - 1))
     
146.     {
     
147.         p = p->next;
     
148.         j++;
     
149.     }
     
150.     if (!(p->next) || (j > i - 1))
     
151.     {
     
152.         return 0;
     
153.     }
     
154.     del = p->next;
     
155.     p->next = del->next;
     
156. 
     
157.     free(del);
     
158.     return 1;
     
159. }
     
160. void printlist(LinkList *headpoint) // 打印输出表中元素
     
161. {
     
162.     printf("\n当前表中元素如下\n");
     
163.     LinkList *p = headpoint->next;
     
164.     putchar('{');
     
165.     while (p != NULL)
     
166.     {
     
167.         printf("%d ", p->elem);
     
168.         p = p->next;
     
169.     }
     
170.     putchar('}');
     
171. }

复制代码

运行结果

1. ##创建链表##
   
2. 
   
3. 请输入链表中元素值，以空格分隔(如，从键盘上依次输入21 18 30 75 42 56)：21 18 30 75 42 56
   
4. 
   
5. 当前表中元素如下
   
6. {56 42 75 30 18 21 }
   
7. 
   
8. ##插入操作##
   
9. 
   
10. 请输入第一次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:2 2
    
11. 在第2个位置插入2成功
    
12. 
    
13. 当前表中元素如下
    
14. {56 2 42 75 30 18 21 }
    
15. 请输入第二次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:5 5
    
16. 在第5个位置插入5成功
    
17. 
    
18. 当前表中元素如下
    
19. {56 2 42 75 5 30 18 21 }
    
20. 
    
21. ##删除操作##
    
22. 
    
23. 请输入第一次要删除元素的位置（如 2 表示删除第2个位置的数值）:2
    
24. 删除第2个数据元素成功
    
25. 
    
26. 当前表中元素如下
    
27. {56 42 75 5 30 18 21 }
    
28. 
    
29. 请输入第二次要删除元素的位置（如 2 表示删除第2个位置的数值）:5
    
30. 删除第5个数据元素成功
    
31. 
    
32. 当前表中元素如下
    
33. {56 42 75 5 18 21 }
    
34. 
    
35. =====顺序表初始化、插入，删除等操作已完成，程序结束！=====
    
36. 
    
37. 请按任意键继续. . .

复制代码

跳转到最佳答案楼层

陶远航

您的代码中存在一些问题，导致了错误。以下是我发现的一些问题：

1. 在 InitList 和 CreateList 函数中，您使用 malloc 分配内存时，应该使用 sizeof(struct LinkList) 而不是 sizeof(struct LinkList *)。因为您需要的是一个 LinkList 结构体的大小，而不是指针的大小。

2. 在 InitList 函数中，您试图修改传入的指针 L，但是这个修改在函数外部是不可见的。因为在 C 语言中，函数参数是通过值传递的，所以您不能直接修改传入的指针。如果您想要修改传入的指针，您需要传入指针的指针。

以下是修改后的代码：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #define MaxSize 50
   
4. typedef int ElemType;
   
5. 
   
6. typedef struct LinkList {
   
7.     ElemType elem;
   
8.     struct LinkList *next;
   
9. } LinkList;
   
10. 
    
11. void InitList(LinkList **L);
    
12. void CreateList(LinkList *L, ElemType a[], ElemType n);
    
13. ElemType ListInsert(LinkList *L, ElemType i, ElemType e);
    
14. ElemType ListDelete(LinkList *L, ElemType i);
    
15. void printlist(LinkList *headpoint);
    
16. 
    
17. int main(void) {
    
18.     LinkList *headpoint = NULL;
    
19.     InitList(&headpoint);
    
20.     // ... 其他代码保持不变
    
21. }
    
22. 
    
23. void InitList(LinkList **L) {
    
24.     *L = (struct LinkList *)malloc(sizeof(struct LinkList));
    
25.     (*L)->next = NULL;
    
26. }
    
27. 
    
28. void CreateList(LinkList *L, ElemType a[], int n) {
    
29.     LinkList *pre = L;
    
30.     int i;
    
31.     for (i = n - 1; i >= 0; i--) {
    
32.         LinkList *t = (struct LinkList *)malloc(sizeof(struct LinkList));
    
33.         t->elem = a[ i];
    
34.         t->next = NULL;
    
35.         pre->next = t;
    
36.         pre = pre->next;
    
37.     }
    
38. }
    
39. 
    
40. // ... 其他函数保持不变
    

复制代码

这样修改后，您的代码应该可以正常运行了。
请注意，本回答来自GPT-4
如果问题已经解决，请设置最佳答案

Mike_python小

你好，根据代码和错误信息来看，可能是以下几个问题导致了报错：

1. ElemType没有定义。在代码中，ElemType是通过typedef定义的，可以尝试将其改为int。

2. malloc()分配内存失败。在代码中，InitList()函数中的malloc()分配内存的语句可能出现了错误。你可以检查一下是否有足够的内存可用。

3. 传入参数的类型不正确。如果使用了错误的参数类型调用函数，则会导致程序崩溃或结果出错。你可以检查一下函数声明和参数类型是否一致，以及传入的参数是否符合函数参数类型的要求。

希望这些信息能帮助你解决问题！

球一个最佳答案谢谢啦！这对我非常重要！

isdkz

这段代码中会报错的原因是在初始化链表的函数  InitList  中，传入的参数是指针类型  LinkList *L ，但是在函数内部重新为  L  分配了内存，导致原本传入的指针所指向的内存被覆盖，最终导致程序运行时出现了错误。

为了解决这个问题，可以将  InitList  函数改为传入指向指针的指针类型，即  LinkList **L ，这样可以在函数内部直接修改指针所指向的内存，而不会覆盖原本传入的指针。

修改后的  InitList  函数代码如下：

1. void InitList(LinkList **L) /* 初始化链表 */
   
2. {
   
3.     *L = (struct LinkList *)malloc(sizeof(struct LinkList)); // 修改为 *L
   
4.     (*L)->next = NULL; // 修改为 (*L)->next
   
5. }
   

复制代码

同时，在  main  函数中调用  InitList  函数时需要传入指向指针的指针，即  &headpoint 。

修改后的  main  函数代码如下：

1. int main(void)
   
2. {
   
3.     LinkList head;
   
4.     LinkList *headpoint = &head;
   
5.     ElemType elements[MaxSize], n = 0, insertposition1, insertvalue1, insertposition2, insertvalue2, delete1, delete2;
   
6.     InitList(&headpoint); // 修改为传入指向指针的指针
   
7.     printf("##创建链表##\n\n");
   
8.     printf("请输入链表中元素值，以空格分隔(如，从键盘上依次输入21 18 30 75 42 56)：");
   
9.     for (int i = 0; i < MaxSize; i++)
   
10.     {
    
11.         scanf("%d", &elements[ i]);
    
12.         n++;
    
13.         if (getchar() == '\n')
    
14.         {
    
15.             break;
    
16.         }
    
17.     }
    
18.     CreateList(headpoint, elements, n);
    
19.     printlist(headpoint); // 输出各元素的值
    
20.     putchar('\n');
    
21.     printf(
    
22.         "\n##插入操作##\n\n"
    
23.         "请输入第一次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:");
    
24.     scanf("%d %d", &insertposition1, &insertvalue1);
    
25.     if (ListInsert(headpoint, insertposition1, insertvalue1))
    
26.     {
    
27.         printf("在第%d个位置插入%d成功\n", insertposition1, insertvalue1);
    
28.     }
    
29.     else
    
30.     {
    
31.         printf("在第%d个位置插入%d失败，插入位置不合法\n", insertposition1, insertvalue1);
    
32.     }
    
33.     printlist(headpoint);
    
34.     putchar('\n');
    
35.     printf(
    
36.         "请输入第二次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:");
    
37.     scanf("%d %d", &insertposition2, &insertvalue2);
    
38.     if (ListInsert(headpoint, insertposition2, insertvalue2))
    
39.     {
    
40.         printf("在第%d个位置插入%d成功\n", insertposition2, insertvalue2);
    
41.     }
    
42.     else
    
43.     {
    
44.         printf("在第%d个位置插入%d失败，插入位置不合法\n", insertposition2, insertvalue2);
    
45.     }
    
46.     printlist(headpoint);
    
47.     putchar('\n');
    
48.     printf(
    
49.         "\n##删除操作##\n\n"
    
50.         "请输入第一次要删除元素的位置（如 2 表示删除第2个位置的数值）:");
    
51.     scanf("%d", &delete1);
    
52.     if (ListDelete(headpoint, delete1))
    
53.     {
    
54.         printf("删除第%d个数据元素成功\n", delete1);
    
55.     }
    
56.     else
    
57.     {
    
58.         printf("删除第%d个数据元素失败，删除位置不合法\n", delete1);
    
59.     }
    
60.     printlist(headpoint);
    
61.     putchar('\n');
    
62.     printf(
    
63.         "\n请输入第二次要删除元素的位置（如 2 表示删除第2个位置的数值）:");
    
64.     scanf("%d", &delete2);
    
65.     if (ListDelete(headpoint, delete2))
    
66.     {
    
67.         printf("删除第%d个数据元素成功\n", delete2);
    
68.     }
    
69.     else
    
70.     {
    
71.         printf("删除第%d个数据元素失败,删除位置不合法\n", delete2);
    
72.     }
    
73.     printlist(headpoint);
    
74.     putchar('\n');
    
75.     while (headpoint != NULL) // 为了防止内存泄漏，最后进行内存释放
    
76.     {
    
77.         LinkList *temp = headpoint;
    
78.         headpoint = headpoint->next;
    
79.         free(temp);
    
80.     }
    
81. 
    
82.     printf("\n=====顺序表初始化、插入，删除等操作已完成，程序结束！=====\n\n");
    
83.     system("pause");
    
84.     return 0;
    
85. }
    

复制代码

1613551

不行，都不行，哎

额外减小

应该是free的时候发生访问非法指针的错误。你是运行时错误还是编译错误？

额外减小

我知道了。
请你看一下代码的第18行：

1. LinkList *headpoint = &head;

复制代码

可以发现，这里的 headpoint 变量并不是用 malloc 动态申请的内存空间指针，而是一个静态的指针。所以是不能被 free 函数删除的。

所以只需删除 headpoint 指向的一系列动态内存空间即可。

修改后的代码（仅修改主函数最后几句）

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #define MaxSize 50
   
4. typedef int ElemType; // 把int替换成了Elemtype
   
5. typedef struct LinkList
   
6. {
   
7.     ElemType elem;                                        // 存储整形元素
   
8.     struct LinkList *next;                                // 指向直接后继元素的指针
   
9. } LinkList;                                               // 等同于用typedef把struct LinkList定义成Linklist就不需要再输入struct LinkList，可以直接输入LinkList
   
10. void InitList(LinkList *L);                               // 初始化链表声明
    
11. void CreateList(LinkList *L, ElemType a[], ElemType n);   // 创建链表声明
    
12. ElemType ListInsert(LinkList *L, ElemType i, ElemType e); // 链表插入声明
    
13. ElemType ListDelete(LinkList *L, ElemType i);             // 删除链表声明
    
14. void printlist(LinkList *headpoint);                      // 打印输出表中元素
    
15. int main(void)
    
16. {
    
17.     LinkList head;                                                                                                     // 头结点
    
18.     LinkList *headpoint = &head;                                                                                       // 指向头结点的指针（结构体变量并不指向结构体，所以需要声明结构体指针）
    
19.     ElemType elements[MaxSize], n = 0, insertposition1, insertvalue1, insertposition2, insertvalue2, delete1, delete2; //
    
20.     InitList(headpoint);
    
21.     printf("##创建链表##\n\n");
    
22.     printf("请输入链表中元素值，以空格分隔(如，从键盘上依次输入21 18 30 75 42 56)：");
    
23.     for (int i = 0; i < MaxSize; i++)
    
24.     {
    
25.         scanf("%d", &elements[i]);
    
26.         n++;
    
27.         if (getchar() == '\n')
    
28.         {
    
29.             break;
    
30.         }
    
31.     }
    
32.     CreateList(headpoint, elements, n);
    
33.     printlist(headpoint); // 输出各元素的值
    
34.     putchar('\n');
    
35.     printf(
    
36.         "\n##插入操作##\n\n"
    
37.         "请输入第一次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:");
    
38.     scanf("%d %d", &insertposition1, &insertvalue1);
    
39.     if (ListInsert(headpoint, insertposition1, insertvalue1))
    
40.     {
    
41.         printf("在第%d个位置插入%d成功\n", insertposition1, insertvalue1);
    
42.     }
    
43.     else
    
44.     {
    
45.         printf("在第%d个位置插入%d失败，插入位置不合法\n", insertposition1, insertvalue1);
    
46.     }
    
47.     printlist(headpoint);
    
48.     putchar('\n');
    
49.     printf(
    
50.         "请输入第二次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:");
    
51.     scanf("%d %d", &insertposition2, &insertvalue2);
    
52.     if (ListInsert(headpoint, insertposition2, insertvalue2))
    
53.     {
    
54.         printf("在第%d个位置插入%d成功\n", insertposition2, insertvalue2);
    
55.     }
    
56.     else
    
57.     {
    
58.         printf("在第%d个位置插入%d失败，插入位置不合法\n", insertposition2, insertvalue2);
    
59.     }
    
60.     printlist(headpoint);
    
61.     putchar('\n');
    
62.     printf(
    
63.         "\n##删除操作##\n\n"
    
64.         "请输入第一次要删除元素的位置（如 2 表示删除第2个位置的数值）:");
    
65.     scanf("%d", &delete1);
    
66.     if (ListDelete(headpoint, delete1))
    
67.     {
    
68.         printf("删除第%d个数据元素成功\n", delete1);
    
69.     }
    
70.     else
    
71.     {
    
72.         printf("删除第%d个数据元素失败，删除位置不合法\n", delete1);
    
73.     }
    
74.     printlist(headpoint);
    
75.     putchar('\n');
    
76.     printf(
    
77.         "\n请输入第二次要删除元素的位置（如 2 表示删除第2个位置的数值）:");
    
78.     scanf("%d", &delete2);
    
79.     if (ListDelete(headpoint, delete2))
    
80.     {
    
81.         printf("删除第%d个数据元素成功\n", delete2);
    
82.     }
    
83.     else
    
84.     {
    
85.         printf("删除第%d个数据元素失败,删除位置不合法\n", delete2);
    
86.     }
    
87.     printlist(headpoint);
    
88.     putchar('\n');
    
89.     headpoint=headpoint->next;
    
90.     while (headpoint != NULL) // 为了防止内存泄漏，最后进行内存释放
    
91.     {
    
92.         LinkList *temp = headpoint;
    
93.         
    
94.         headpoint = headpoint->next;
    
95.         
    
96.         free(temp);
    
97.         
    
98.     }
    
99. 
    
100.     printf("\n=====顺序表初始化、插入，删除等操作已完成，程序结束！=====\n\n");
     
101.     system("pause");
     
102.     return 0;
     
103. }
     
104. void InitList(LinkList *L) /* 初始化链表 */
     
105. {
     
106.     L = (struct LinkList *)malloc(sizeof(struct LinkList *));
     
107.     L->next = NULL;
     
108. }
     
109. void CreateList(LinkList *L, ElemType a[], int n) /*创建链表 */
     
110. {
     
111.     LinkList *pre = L;
     
112.     int i;
     
113.     for (i = n - 1; i >= 0; i--)
     
114.     {
     
115.         LinkList *t = (struct LinkList *)malloc(sizeof(struct LinkList *));
     
116.         t->elem = a[i];
     
117.         t->next = NULL;
     
118.         pre->next = t;
     
119.         pre = pre->next;
     
120.     }
     
121. }
     
122. int ListInsert(LinkList *L, int i, ElemType e) /*按i位置插入元素*/
     
123. {
     
124. 
     
125.     int j = 0;
     
126.     LinkList *p = L;
     
127.     while (p && (j < i - 1))
     
128.     {
     
129.         p = p->next;
     
130.         j++;
     
131.     }
     
132.     if (!p || (j > i - 1))
     
133.         return 0;
     
134.     LinkList *t = (struct LinkList *)malloc(sizeof(struct LinkList *));
     
135.     t->elem = e;
     
136.     t->next = p->next;
     
137.     p->next = t;
     
138.     return 1;
     
139. }
     
140. int ListDelete(LinkList *L, int i) /*删除某个位置的元素*/
     
141. {
     
142.     int j = 0;
     
143.     LinkList *p = L;
     
144.     LinkList *del = NULL;
     
145.     while ((p->next) && (j < i - 1))
     
146.     {
     
147.         p = p->next;
     
148.         j++;
     
149.     }
     
150.     if (!(p->next) || (j > i - 1))
     
151.     {
     
152.         return 0;
     
153.     }
     
154.     del = p->next;
     
155.     p->next = del->next;
     
156. 
     
157.     free(del);
     
158.     return 1;
     
159. }
     
160. void printlist(LinkList *headpoint) // 打印输出表中元素
     
161. {
     
162.     printf("\n当前表中元素如下\n");
     
163.     LinkList *p = headpoint->next;
     
164.     putchar('{');
     
165.     while (p != NULL)
     
166.     {
     
167.         printf("%d ", p->elem);
     
168.         p = p->next;
     
169.     }
     
170.     putchar('}');
     
171. }

复制代码

运行结果

1. ##创建链表##
   
2. 
   
3. 请输入链表中元素值，以空格分隔(如，从键盘上依次输入21 18 30 75 42 56)：21 18 30 75 42 56
   
4. 
   
5. 当前表中元素如下
   
6. {56 42 75 30 18 21 }
   
7. 
   
8. ##插入操作##
   
9. 
   
10. 请输入第一次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:2 2
    
11. 在第2个位置插入2成功
    
12. 
    
13. 当前表中元素如下
    
14. {56 2 42 75 30 18 21 }
    
15. 请输入第二次要插入的位置和插入的数值（插入位置和插入数值之间以空格相隔，如2 5，表示第2个位置插入数值5）:5 5
    
16. 在第5个位置插入5成功
    
17. 
    
18. 当前表中元素如下
    
19. {56 2 42 75 5 30 18 21 }
    
20. 
    
21. ##删除操作##
    
22. 
    
23. 请输入第一次要删除元素的位置（如 2 表示删除第2个位置的数值）:2
    
24. 删除第2个数据元素成功
    
25. 
    
26. 当前表中元素如下
    
27. {56 42 75 5 30 18 21 }
    
28. 
    
29. 请输入第二次要删除元素的位置（如 2 表示删除第2个位置的数值）:5
    
30. 删除第5个数据元素成功
    
31. 
    
32. 当前表中元素如下
    
33. {56 42 75 5 18 21 }
    
34. 
    
35. =====顺序表初始化、插入，删除等操作已完成，程序结束！=====
    
36. 
    
37. 请按任意键继续. . .

复制代码

1613551

额外减小 发表于 2023-10-15 20:09
我知道了。
请你看一下代码的第18行：

感谢大佬！！！！！

1613551

额外减小 发表于 2023-10-15 20:09
我知道了。
请你看一下代码的第18行：

大佬，我还有一点不是很清楚，就是代码的第115和第134行，它必须得删掉sizeof（struct LinkList *）中的*才能正常运行，不然在free的时候就会报错

额外减小

1613551 发表于 2023-10-15 20:56
大佬，我还有一点不是很清楚，就是代码的第115和第134行，它必须得删掉sizeof（struct LinkList *）中的* ...

对。因为指针指向的是一个 struct LinkList 变量，那就是申请一个 sizeof（struct LinkList)的动态内存空间。