[已解决]自己写的链表有点问题

w349695434051

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct _node{                                                                        //定义链表节点
   
5.         int value;                                                                                        //每个节点中包含两个元素 他存储的值value 还有便于检索的下标index
   
6.         int index;
   
7.         struct _node* next;
   
8. }Node;
   
9. 
   
10. typedef struct _list{                                                                        //定义链表
    
11.         int number;                                                                                        //每个链表包含number 代表他一共含有几个节点
    
12.         Node* head;                                                                                        //链表的头
    
13.         Node* tail;                                                                                        //链表的tail 指向链表最后一个节点 用来延长链表的
    
14. }List;
    
15. 
    
16. Node* list_add(List* list, int number);                                        //定义链表延长函数
    
17. int list_print(List *list);                                                                //链表输出节点的值的函数
    
18. Node* list_at(List* list, int index);                                        //根据下标定位节点的函数
    
19. Node* list_insert(List* list, int index, int number);        //再链表中插入结点的函数
    
20. int list_retrieval(List* list);                                                        //插入或者删除节点后 对链表节点重新排下标的函数
    
21. int list_delete(List* list, int index);                                        //输出链表结点的函数
    
22. Node* list_found(List* list, int number);                                //根据链表的值输出节点地址的函数
    
23. void list_free(List* list);                                                                //free链表的函数
    
24. 
    
25. Node* list_add(List* list, int number)
    
26. {
    
27.         Node* p = (Node*)malloc(sizeof(Node));
    
28.         p -> value = number;
    
29.         p -> next = NULL;
    
30.         if(list -> head)                                                                        //判断链表是否为空链表
    
31.         {                                                                                                
    
32.                 list -> tail -> next = p;                                                //不是的话让指向最后一个节点的tail的next指向新定义的节点
    
33.                 p -> index = list -> tail -> index + 1;                        //他的下标就是最后节点下标加一
    
34.                 list -> number++;                                                                //链表节点数量加一
    
35.         }else                                                                                                        
    
36.         {                                                                                                        //链表是空链表
    
37.                 list -> head = p;                                                                //链表头指向新定义的节点
    
38.                 p -> index = 0;                                                                        //下标为零
    
39.                 list -> number = 1;                                                                //节点数量初始化为一
    
40.         }
    
41.         list -> tail = p;                                                                        //最后让tail指向新定义的节点 作为链表最后一个节点
    
42. }
    
43. 
    
44. int list_print(List *list)
    
45. {
    
46.         int ret = 0;
    
47.         if(list -> head)                                                                        //打印函数 如果为空链表不调用函数返回值为零
    
48.         {
    
49.                 ret = 1;
    
50.                 Node *p = NULL;
    
51.                 for(p = list -> head; p; p = p -> next)
    
52.                 {
    
53.                         printf("%d", p -> value);
    
54.                         if(p -> next)                                                                //链表除了最后一个节点都打印一个tab
    
55.                                 printf("\t");
    
56.                 }
    
57.                 printf("\n");
    
58.         }
    
59.         return ret;
    
60. }
    
61. 
    
62. Node* list_at(List* list, int index)
    
63. {
    
64.         Node* p = NULL;
    
65.         if(index < list -> number && index >= 0)                        //输入有效下表进入函数 否则返回零地址
    
66.                 for(p = list -> head; p; p = p -> next)
    
67.                         if(p -> index == index)
    
68.                                 break;
    
69.         return p;
    
70. }
    
71. 
    
72. Node* list_insert(List* list, int index, int number)        //链表插入函数
    
73. {
    
74.         Node* p = NULL;
    
75.         
    
76.         if(index <= list -> number && index >= 0)                        //判断述如下表是否有效
    
77.         {
    
78.                 p = (Node*)malloc(sizeof(Node));
    
79.                 p -> value = number;
    
80.                 p -> next = NULL;
    
81.                
    
82.                 if(index <= list -> number && index)                        //当插入的位置 不为第一个时
    
83.                         list_at(list, index - 1) -> next = p;                //调用取址函数让插入的前一个节点指向新插入的节点
    
84.                 else if(index == 0)                                                                //当插入位置 为第一个时
    
85.                         list -> head = p;                                                        //链表头指向新节点
    
86.                         
    
87.                 if(index == list -> number)                                                //当插入位置为最后一个 相当于延长了一个节点
    
88.                         p -> next = NULL;                                                        //新节点next指向null
    
89.                 else
    
90.                         p -> next = list_at(list, index);                        //否则的话 next指向被插入的节点
    
91.                         
    
92.                 list_retrieval(list);                                                        //调用排序函数对链表下标在排序
    
93.         }
    
94. }
    
95. 
    
96. int list_retrieval(List* list)
    
97. {
    
98.         int ret = 0;
    
99.         int reindex = 0;
    
100.         Node* rep = NULL;
     
101.         if(list -> head)
     
102.         {
     
103.                 ret = 1;
     
104.                 for(rep = list -> head; rep ！= NULL; rep = rep -> next)                //重点就是这个排序函数 进到for循环之后就死循环了 但我看着也没有问题啊 ！！
     
105.                 {
     
106.                         int a;
     
107.                         rep -> index = reindex++;
     
108.                 }
     
109.         }
     
110.         return ret;
     
111. }
     
112. 
     
113. int list_delete(List* list, int index)                                                //节点删除函数
     
114. {
     
115.         int ret = 0;
     
116.         if(list -> head && list -> number > index && index >= 0)        //如果链表为空链表并且下标无效的话不调用函数
     
117.         {
     
118.                 ret = 1;
     
119.                 Node* p = NULL;
     
120.                 if(index > 0)                                                                                //删除的节点不是第一个节点
     
121.                         list_at(list, index - 1) -> next =  list_at(list, index)-> next;        //调用取址函数
     
122.                 else
     
123.                         list -> head = list_at(list, index) -> next;        //删除的是第一个节点
     
124.                 free(p);
     
125.                 list_retrieval(list);                                                                                //对删除之后的链表下标排序
     
126.         }
     
127.         return ret;
     
128. }
     
129. 
     
130. Node* list_found(List* list, int number)                                        //根据链表的值输出节点地址的函数
     
131. {
     
132.         Node* p = NULL;
     
133.         for(p = list -> head; p; p = p -> next)
     
134.                 if(p -> value == number)
     
135.                         break;
     
136.         return p;
     
137. }
     
138. 
     
139. void list_free(List* list)                                                                        //free链表的函数
     
140. {
     
141.         Node* p = list -> head;
     
142.         Node* q = NULL;
     
143.         while(p)
     
144.         {
     
145.                 q = p -> next;
     
146.                 free(p);
     
147.                 p = q;
     
148.         }
     
149. }
     
150. 
     
151. int main()
     
152. {
     
153.         List list;
     
154.         list.head = NULL;
     
155.         list.tail = NULL;
     
156.         
     
157.         list_add(&list, 1);
     
158.         list_add(&list, 2);
     
159.         list_add(&list, 3);
     
160.         
     
161.         list_print(&list);
     
162.         
     
163.         list_insert(&list, 0, 4);
     
164.         list_insert(&list, 4, 5);
     
165.         
     
166.         list_delete(&list, 0);
     
167.         list_print(&list);
     
168.         list_delete(&list, 1);
     
169.         list_print(&list);
     
170.         list_delete(&list, 0);
     
171.         list_print(&list);
     
172.         
     
173.         list_print(&list);
     
174.         
     
175.         list_free(&list);
     
176.         
     
177.         return 0;
     
178. }

复制代码

调用insert函数还有delete函数
进入retrieval的for语句就死循环了
链表这几天刚学的
求大佬指点一下
我看着逻辑没啥问题但怎么改都是死循环
真是要崩溃了
求助

最佳答案

月排行榜 / 总排行榜

FishC_GPT

2023-12-1 05:32:16

小甲鱼的二师兄 发表于 2023-12-01 05:31
#include
#include

typedef struct _node{      ...

你的代码中，在排序函数 `list_retrieval()` 的 for 循环中，有一个问题导致了死循环。问题出在循环条件上（`rep ！= NULL`），你使用了中文的感叹号，但实际应该使用英文的感叹号 `!=` 。

修复这个问题后，可以将循环条件修改为 `rep != NULL`，就可以避免死循环了。这样，每次循环时，`rep` 都会指向下一个节点，直到链表末尾为止。

同时，我还注意到你在删除节点的代码中，没有正确释放内存。在 `list_delete()` 函数中，你定义了一个指针 `p` 来指向要删除的节点，但在释放内存之前，你没有将 `p` 更新为要删除节点的下一个节点，导致内存泄漏。

以下是修改后的代码：

1. #include <stdio.h>
2. #include <stdlib.h>
4. typedef struct _node {
5.     int value;
6.     int index;
7.     struct _node* next;
8. } Node;
10. typedef struct _list {
11.     int number;
12.     Node* head;
13.     Node* tail;
14. } List;
16. Node* list_add(List* list, int number);
17. int list_print(List *list);
18. Node* list_at(List* list, int index);
19. Node* list_insert(List* list, int index, int number);
20. int list_retrieval(List* list);
21. int list_delete(List* list, int index);
22. Node* list_found(List* list, int number);
23. void list_free(List* list);
25. Node* list_add(List* list, int number) {
26.     Node* p = (Node*)malloc(sizeof(Node));
27.     p->value = number;
28.     p->next = NULL;
30.     if (list->head) {
31.         list->tail->next = p;
32.         p->index = list->tail->index + 1;
33.         list->number++;
34.     } else {
35.         list->head = p;
36.         p->index = 0;
37.         list->number = 1;
38.     }
40.     list->tail = p;
41.     return p;
42. }
44. int list_print(List *list) {
45.     if (!list->head) {
46.         return 0;
47.     }
49.     Node *p = NULL;
50.     for (p = list->head; p; p = p->next) {
51.         printf("%d", p->value);
52.         if (p->next) {
53.             printf("\t");
54.         }
55.     }
56.     printf("\n");
58.     return 1;
59. }
61. Node* list_at(List* list, int index) {
62.     Node* p = NULL;
63.     if (index < list->number && index >= 0) {
64.         for (p = list->head; p; p = p->next) {
65.             if (p->index == index) {
66.                 break;
67.             }
68.         }
69.     }
70.     return p;
71. }
73. Node* list_insert(List* list, int index, int number) {
74.     if (index < 0 || index > list->number) {
75.         return NULL; // 非法的下标
76.     }
78.     Node* p = (Node*)malloc(sizeof(Node));
79.     p->value = number;
81.     if (index == 0) {
82.         p->next = list->head;
83.         list->head = p;
84.         if (list->number == 0) {
85.             list->tail = p;
86.         }
87.     } else {
88.         Node* prev = list_at(list, index-1);
89.         p->next = prev->next;
90.         prev->next = p;
91.         if (index == list->number) {
92.             list->tail = p;
93.         }
94.     }
96.     list_retrieval(list);
97.     return p;
98. }
100. int list_retrieval(List* list) {
101.     if (!list->head) {
102.         return 0;
103.     }
105.     int reindex = 0;
106.     Node* rep = NULL;
107.     for (rep = list->head; rep != NULL; rep = rep->next) {
108.         rep->index = reindex++;
109.     }
110.     return 1;
111. }
113. int list_delete(List* list, int index) {
114.     if (!list->head || index < 0 || index >= list->number) {
115.         return 0;
116.     }
118.     Node* p = NULL;
119.     if (index == 0) {
120.         p = list->head;
121.         list->head = list->head->next;
122.         if (list->number == 1) {
123.             list->tail = NULL;
124.         }
125.     } else {
126.         Node* prev = list_at(list, index-1);
127.         p = prev->next;
128.         prev->next = p->next;
129.         if (index == list->number - 1) {
130.             list->tail = prev;
131.         }
132.     }
134.     free(p);
135.     list_retrieval(list);
136.     return 1;
137. }
139. Node* list_found(List* list, int number) {
140.     Node* p = NULL;
141.     for (p = list->head; p; p = p->next) {
142.         if (p->value == number) {
143.             break;
144.         }
145.     }
146.     return p;
147. }
149. void list_free(List* list) {
150.     Node* p = list->head;
151.     Node* q = NULL;
152.     while (p) {
153.         q = p->next;
154.         free(p);
155.         p = q;
156.     }
157. }
159. int main() {
160.     List list;
161.     list.head = NULL;
162.     list.tail = NULL;
163.    
164.     list_add(&list, 1);
165.     list_add(&list, 2);
166.     list_add(&list, 3);
168.     list_print(&list);
169.    
170.     list_insert(&list, 0, 4);
171.     list_insert(&list, 4, 5);
172.    
173.     list_delete(&list, 0);
174.     list_print(&list);
176.     list_delete(&list, 1);
177.     list_print(&list);
179.     list_delete(&list, 0);
180.     list_print(&list);
182.     list_free(&list);
184.     return 0;
185. }

复制代码

现在，你的插入和删除操作应该能够正常运行，并且循环也会正确退出。希望这对你有帮助！如果还有其他问题，请随时提问。

以上回复来自 -- ChatGPT（FishC官方接口），如未能正确解答您的问题，请继续追问。

跳转到最佳答案楼层

小甲鱼的二师兄

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct _node{                                                                        //定义链表节点
   
5.         int value;                                                                                        //每个节点中包含两个元素 他存储的值value 还有便于检索的下标index
   
6.         int index;
   
7.         struct _node* next;
   
8. }Node;
   
9. 
   
10. typedef struct _list{                                                                        //定义链表
    
11.         int number;                                                                                        //每个链表包含number 代表他一共含有几个节点
    
12.         Node* head;                                                                                        //链表的头
    
13.         Node* tail;                                                                                        //链表的tail 指向链表最后一个节点 用来延长链表的
    
14. }List;
    
15. 
    
16. Node* list_add(List* list, int number);                                        //定义链表延长函数
    
17. int list_print(List *list);                                                                //链表输出节点的值的函数
    
18. Node* list_at(List* list, int index);                                        //根据下标定位节点的函数
    
19. Node* list_insert(List* list, int index, int number);        //再链表中插入结点的函数
    
20. int list_retrieval(List* list);                                                        //插入或者删除节点后 对链表节点重新排下标的函数
    
21. int list_delete(List* list, int index);                                        //输出链表结点的函数
    
22. Node* list_found(List* list, int number);                                //根据链表的值输出节点地址的函数
    
23. void list_free(List* list);                                                                //free链表的函数
    
24. 
    
25. Node* list_add(List* list, int number)
    
26. {
    
27.         Node* p = (Node*)malloc(sizeof(Node));
    
28.         p -> value = number;
    
29.         p -> next = NULL;
    
30.         if(list -> head)                                                                        //判断链表是否为空链表
    
31.         {                                                                                                
    
32.                 list -> tail -> next = p;                                                //不是的话让指向最后一个节点的tail的next指向新定义的节点
    
33.                 p -> index = list -> tail -> index + 1;                        //他的下标就是最后节点下标加一
    
34.                 list -> number++;                                                                //链表节点数量加一
    
35.         }else                                                                                                        
    
36.         {                                                                                                        //链表是空链表
    
37.                 list -> head = p;                                                                //链表头指向新定义的节点
    
38.                 p -> index = 0;                                                                        //下标为零
    
39.                 list -> number = 1;                                                                //节点数量初始化为一
    
40.         }
    
41.         list -> tail = p;                                                                        //最后让tail指向新定义的节点 作为链表最后一个节点
    
42. }
    
43. 
    
44. int list_print(List *list)
    
45. {
    
46.         int ret = 0;
    
47.         if(list -> head)                                                                        //打印函数 如果为空链表不调用函数返回值为零
    
48.         {
    
49.                 ret = 1;
    
50.                 Node *p = NULL;
    
51.                 for(p = list -> head; p; p = p -> next)
    
52.                 {
    
53.                         printf("%d", p -> value);
    
54.                         if(p -> next)                                                                //链表除了最后一个节点都打印一个tab
    
55.                                 printf("\t");
    
56.                 }
    
57.                 printf("\n");
    
58.         }
    
59.         return ret;
    
60. }
    
61. 
    
62. Node* list_at(List* list, int index)
    
63. {
    
64.         Node* p = NULL;
    
65.         if(index < list -> number && index >= 0)                        //输入有效下表进入函数 否则返回零地址
    
66.                 for(p = list -> head; p; p = p -> next)
    
67.                         if(p -> index == index)
    
68.                                 break;
    
69.         return p;
    
70. }
    
71. 
    
72. Node* list_insert(List* list, int index, int number)        //链表插入函数
    
73. {
    
74.         Node* p = NULL;
    
75.         
    
76.         if(index <= list -> number && index >= 0)                        //判断述如下表是否有效
    
77.         {
    
78.                 p = (Node*)malloc(sizeof(Node));
    
79.                 p -> value = number;
    
80.                 p -> next = NULL;
    
81.                
    
82.                 if(index <= list -> number && index)                        //当插入的位置 不为第一个时
    
83.                         list_at(list, index - 1) -> next = p;                //调用取址函数让插入的前一个节点指向新插入的节点
    
84.                 else if(index == 0)                                                                //当插入位置 为第一个时
    
85.                         list -> head = p;                                                        //链表头指向新节点
    
86.                         
    
87.                 if(index == list -> number)                                                //当插入位置为最后一个 相当于延长了一个节点
    
88.                         p -> next = NULL;                                                        //新节点next指向null
    
89.                 else
    
90.                         p -> next = list_at(list, index);                        //否则的话 next指向被插入的节点
    
91.                         
    
92.                 list_retrieval(list);                                                        //调用排序函数对链表下标在排序
    
93.         }
    
94. }
    
95. 
    
96. int list_retrieval(List* list)
    
97. {
    
98.         int ret = 0;
    
99.         int reindex = 0;
    
100.         Node* rep = NULL;
     
101.         if(list -> head)
     
102.         {
     
103.                 ret = 1;
     
104.                 for(rep = list -> head; rep ！= NULL; rep = rep -> next)                //重点就是这个排序函数 进到for循环之后就死循环了 但我看着也没有问题啊 ！！
     
105.                 {
     
106.                         int a;
     
107.                         rep -> index = reindex++;
     
108.                 }
     
109.         }
     
110.         return ret;
     
111. }
     
112. 
     
113. int list_delete(List* list, int index)                                                //节点删除函数
     
114. {
     
115.         int ret = 0;
     
116.         if(list -> head && list -> number > index && index >= 0)        //如果链表为空链表并且下标无效的话不调用函数
     
117.         {
     
118.                 ret = 1;
     
119.                 Node* p = NULL;
     
120.                 if(index > 0)                                                                                //删除的节点不是第一个节点
     
121.                         list_at(list, index - 1) -> next =  list_at(list, index)-> next;        //调用取址函数
     
122.                 else
     
123.                         list -> head = list_at(list, index) -> next;        //删除的是第一个节点
     
124.                 free(p);
     
125.                 list_retrieval(list);                                                                                //对删除之后的链表下标排序
     
126.         }
     
127.         return ret;
     
128. }
     
129. 
     
130. Node* list_found(List* list, int number)                                        //根据链表的值输出节点地址的函数
     
131. {
     
132.         Node* p = NULL;
     
133.         for(p = list -> head; p; p = p -> next)
     
134.                 if(p -> value == number)
     
135.                         break;
     
136.         return p;
     
137. }
     
138. 
     
139. void list_free(List* list)                                                                        //free链表的函数
     
140. {
     
141.         Node* p = list -> head;
     
142.         Node* q = NULL;
     
143.         while(p)
     
144.         {
     
145.                 q = p -> next;
     
146.                 free(p);
     
147.                 p = q;
     
148.         }
     
149. }
     
150. 
     
151. int main()
     
152. {
     
153.         List list;
     
154.         list.head = NULL;
     
155.         list.tail = NULL;
     
156.         
     
157.         list_add(&list, 1);
     
158.         list_add(&list, 2);
     
159.         list_add(&list, 3);
     
160.         
     
161.         list_print(&list);
     
162.         
     
163.         list_insert(&list, 0, 4);
     
164.         list_insert(&list, 4, 5);
     
165.         
     
166.         list_delete(&list, 0);
     
167.         list_print(&list);
     
168.         list_delete(&list, 1);
     
169.         list_print(&list);
     
170.         list_delete(&list, 0);
     
171.         list_print(&list);
     
172.         
     
173.         list_print(&list);
     
174.         
     
175.         list_free(&list);
     
176.         
     
177.         return 0;
     
178. }

复制代码

调用insert函数还有delete函数
进入retrieval的for语句就死循环了
@FishC_GPT

FishC_GPT

小甲鱼的二师兄 发表于 2023-12-01 05:31
#include
#include

typedef struct _node{      ...

你的代码中，在排序函数 `list_retrieval()` 的 for 循环中，有一个问题导致了死循环。问题出在循环条件上（`rep ！= NULL`），你使用了中文的感叹号，但实际应该使用英文的感叹号 `!=` 。

修复这个问题后，可以将循环条件修改为 `rep != NULL`，就可以避免死循环了。这样，每次循环时，`rep` 都会指向下一个节点，直到链表末尾为止。

同时，我还注意到你在删除节点的代码中，没有正确释放内存。在 `list_delete()` 函数中，你定义了一个指针 `p` 来指向要删除的节点，但在释放内存之前，你没有将 `p` 更新为要删除节点的下一个节点，导致内存泄漏。

以下是修改后的代码：

1. #include <stdio.h>
2. #include <stdlib.h>
4. typedef struct _node {
5.     int value;
6.     int index;
7.     struct _node* next;
8. } Node;
10. typedef struct _list {
11.     int number;
12.     Node* head;
13.     Node* tail;
14. } List;
16. Node* list_add(List* list, int number);
17. int list_print(List *list);
18. Node* list_at(List* list, int index);
19. Node* list_insert(List* list, int index, int number);
20. int list_retrieval(List* list);
21. int list_delete(List* list, int index);
22. Node* list_found(List* list, int number);
23. void list_free(List* list);
25. Node* list_add(List* list, int number) {
26.     Node* p = (Node*)malloc(sizeof(Node));
27.     p->value = number;
28.     p->next = NULL;
30.     if (list->head) {
31.         list->tail->next = p;
32.         p->index = list->tail->index + 1;
33.         list->number++;
34.     } else {
35.         list->head = p;
36.         p->index = 0;
37.         list->number = 1;
38.     }
40.     list->tail = p;
41.     return p;
42. }
44. int list_print(List *list) {
45.     if (!list->head) {
46.         return 0;
47.     }
49.     Node *p = NULL;
50.     for (p = list->head; p; p = p->next) {
51.         printf("%d", p->value);
52.         if (p->next) {
53.             printf("\t");
54.         }
55.     }
56.     printf("\n");
58.     return 1;
59. }
61. Node* list_at(List* list, int index) {
62.     Node* p = NULL;
63.     if (index < list->number && index >= 0) {
64.         for (p = list->head; p; p = p->next) {
65.             if (p->index == index) {
66.                 break;
67.             }
68.         }
69.     }
70.     return p;
71. }
73. Node* list_insert(List* list, int index, int number) {
74.     if (index < 0 || index > list->number) {
75.         return NULL; // 非法的下标
76.     }
78.     Node* p = (Node*)malloc(sizeof(Node));
79.     p->value = number;
81.     if (index == 0) {
82.         p->next = list->head;
83.         list->head = p;
84.         if (list->number == 0) {
85.             list->tail = p;
86.         }
87.     } else {
88.         Node* prev = list_at(list, index-1);
89.         p->next = prev->next;
90.         prev->next = p;
91.         if (index == list->number) {
92.             list->tail = p;
93.         }
94.     }
96.     list_retrieval(list);
97.     return p;
98. }
100. int list_retrieval(List* list) {
101.     if (!list->head) {
102.         return 0;
103.     }
105.     int reindex = 0;
106.     Node* rep = NULL;
107.     for (rep = list->head; rep != NULL; rep = rep->next) {
108.         rep->index = reindex++;
109.     }
110.     return 1;
111. }
113. int list_delete(List* list, int index) {
114.     if (!list->head || index < 0 || index >= list->number) {
115.         return 0;
116.     }
118.     Node* p = NULL;
119.     if (index == 0) {
120.         p = list->head;
121.         list->head = list->head->next;
122.         if (list->number == 1) {
123.             list->tail = NULL;
124.         }
125.     } else {
126.         Node* prev = list_at(list, index-1);
127.         p = prev->next;
128.         prev->next = p->next;
129.         if (index == list->number - 1) {
130.             list->tail = prev;
131.         }
132.     }
134.     free(p);
135.     list_retrieval(list);
136.     return 1;
137. }
139. Node* list_found(List* list, int number) {
140.     Node* p = NULL;
141.     for (p = list->head; p; p = p->next) {
142.         if (p->value == number) {
143.             break;
144.         }
145.     }
146.     return p;
147. }
149. void list_free(List* list) {
150.     Node* p = list->head;
151.     Node* q = NULL;
152.     while (p) {
153.         q = p->next;
154.         free(p);
155.         p = q;
156.     }
157. }
159. int main() {
160.     List list;
161.     list.head = NULL;
162.     list.tail = NULL;
163.    
164.     list_add(&list, 1);
165.     list_add(&list, 2);
166.     list_add(&list, 3);
168.     list_print(&list);
169.    
170.     list_insert(&list, 0, 4);
171.     list_insert(&list, 4, 5);
172.    
173.     list_delete(&list, 0);
174.     list_print(&list);
176.     list_delete(&list, 1);
177.     list_print(&list);
179.     list_delete(&list, 0);
180.     list_print(&list);
182.     list_free(&list);
184.     return 0;
185. }

复制代码

现在，你的插入和删除操作应该能够正常运行，并且循环也会正确退出。希望这对你有帮助！如果还有其他问题，请随时提问。

以上回复来自 -- ChatGPT（FishC官方接口），如未能正确解答您的问题，请继续追问。