单向链表数据插入销毁问题

lwphappy

各位大牛们好,请问在一个已创建的单向链表中插入一个新数据后再执行销毁链表操作没有将这个新插入的结点删除,是否有什么好办法?
代码如下:

1. #include <stdio.h>
   
2. #include <unistd.h>
   
3. #define stLen        sizeof(stNode)
   
4. 
   
5. typedef struct student
   
6. {
   
7.         char        sname[10];
   
8.         int                iage;
   
9.         struct student        *next;
   
10. }stNode;
    
11. 
    
12. //创建一个定长的单向链表
    
13. stNode *create(int num)
    
14. {
    
15.         stNode *p,*q,*head;
    
16.         int icount = 0;
    
17. 
    
18.         p = q = (stNode *)malloc(stLen);
    
19.        
    
20.         head = NULL;
    
21. 
    
22.         while(num--)
    
23.         {
    
24.                 icount++;
    
25. 
    
26.                 p = (stNode *)malloc(stLen);
    
27.                 scanf("%s%d",&p->sname,&p->iage);
    
28. 
    
29.                 if(icount == 1)        head = p;
    
30.                 else q->next = p;
    
31.                 p->next = NULL;
    
32.                 q = p;
    
33.         }
    
34. 
    
35.         q->next = NULL;
    
36. 
    
37.         return head;
    
38. }
    
39. 
    
40. //链表数据打印输出
    
41. void myprint(stNode *node)
    
42. {
    
43.         if(node == NULL)
    
44.         {
    
45.                 printf("输入的链表为空，链表不能为空!\n");
    
46.                 exit (-1);
    
47.         }
    
48. 
    
49.         while(node)
    
50.         {
    
51.                 printf("name->[%s],age->[%d]\n",node->sname,node->iage);
    
52.                 node = node->next;
    
53.         }
    
54. }
    
55. 
    
56. //计算链表长度
    
57. int Node_Length(stNode *node)
    
58. {
    
59.         int iLength = 0;
    
60.         while(node){
    
61.                 node = node->next;
    
62.                 iLength++;
    
63.         }
    
64.         return iLength;
    
65. }
    
66. 
    
67. //删除指定位置记录
    
68. stNode *Node_Delete(stNode *node,int inum)
    
69. {
    
70.         stNode *p1,*p2;
    
71.         int node_length = 0,iRun = 0;
    
72. 
    
73.         if(node == NULL)
    
74.         {
    
75.                 printf("输入的链表为空，链表不能为空!\n");
    
76.                 exit (-1);
    
77.         }
    
78. 
    
79.         p1 =  node;
    
80.         node_length = Node_Length(node);
    
81. 
    
82.         if(node_length < inum)
    
83.         {
    
84.                 printf("输入的链表长度[%d]不足[%d]\n",node_length,inum);
    
85.                 exit (-1);
    
86.         }
    
87. 
    
88.         while(iRun++ < (inum-1))
    
89.         {
    
90.                 p2 = p1;
    
91.                 p1 = p1->next;
    
92.         }
    
93. 
    
94.         if(p1 == node)
    
95.         {
    
96.                 if(node_length == 1)
    
97.                 {
    
98.                         free(node);
    
99.                         node = NULL;
    
100.                 }
     
101.                 else node = p1->next;
     
102.                 free(p1);
     
103.         }
     
104. 
     
105.         else p2->next = p1->next;
     
106. 
     
107.         return node;
     
108. }
     
109. 
     
110. //插入新数据到链表指定位置
     
111. stNode *Node_Insert(stNode *node,stNode *innode,int inum)
     
112. {
     
113.         stNode *p1,*p2;
     
114.         int node_length = 0,iRun = 0;
     
115. 
     
116.         node_length = Node_Length(node);
     
117. 
     
118.         if(node == NULL || inum > node_length || innode == NULL)
     
119.         {
     
120.                 printf("链表为空或需插入的位置[%d]超过链表长度[%d]!\n",inum,node_length);
     
121.                 exit(-1);
     
122.         }
     
123. 
     
124.         p1 = node;
     
125. 
     
126.         while(iRun++ < inum)
     
127.         {
     
128.                 p2 = p1;
     
129.                 p1 = p1->next;
     
130.         }
     
131. 
     
132.         p2->next = innode;
     
133.         p2->next->next = p1;
     
134. 
     
135.         return node;
     
136. }
     
137. 
     
138. //更新链表数据
     
139. stNode *Node_Update(stNode *node,stNode *upnode,int inum)
     
140. {
     
141.         stNode *p1;
     
142.         int node_length = 0,iRun = 0;
     
143. 
     
144.         node_length = Node_Length(node);
     
145. 
     
146.         if(node == NULL || inum > node_length || upnode == NULL)
     
147.         {
     
148.                 printf("链表为空或需插入的位置[%d]超过链表长度[%d]!\n",inum,node_length);
     
149.                 exit(-1);
     
150.         }
     
151. 
     
152.         p1 = node;
     
153. 
     
154.         while(iRun++ < inum-1)
     
155.         {
     
156.                 p1 = p1->next;
     
157.         }
     
158. 
     
159.         strcpy(p1->sname,upnode->sname);
     
160.         p1->iage = upnode->iage;
     
161. 
     
162.         return node;
     
163. }
     
164. 
     
165. //链表逆序
     
166. stNode *Node_Reverse(stNode *node)
     
167. {
     
168.         stNode *next,*prev;
     
169. 
     
170.         prev = NULL;
     
171. 
     
172.         while(node)
     
173.         {
     
174.                 next = node->next;
     
175.                 node->next = prev;
     
176.                 prev = node;
     
177.                 node = next;
     
178.         }
     
179. 
     
180.         return prev;
     
181. }
     
182. 
     
183. //递归算法逆序链表
     
184. stNode *Node_Reverse2(stNode *node)
     
185. {
     
186.         stNode        *NewHead;
     
187. 
     
188.         if(node == NULL || node->next == NULL)
     
189.                 return node;
     
190. 
     
191.         NewHead = Node_Reverse2(node->next);
     
192. 
     
193.         node->next->next = node;
     
194.         node->next = NULL;
     
195. 
     
196.         return NewHead;
     
197. }
     
198. 
     
199. //销毁链表
     
200. stNode *Node_Destroy(stNode *node)
     
201. {
     
202.         stNode *pnode;
     
203. 
     
204.         while(node)
     
205.         {
     
206.                 pnode = node->next;
     
207.                 free(node);
     
208.                 node = pnode;
     
209.         }
     
210. 
     
211.         return node;
     
212. }
     
213. 
     
214. int main()
     
215. {
     
216.         stNode *p,*q,*pn1,*pn2;
     
217.         int iLength = 0;
     
218.         int        iDelete = 0;
     
219.         int        iInsert = 0;
     
220.         int        iUpdate = 0;
     
221.        
     
222.         printf("开始创建链表\n");
     
223.         printf("输入需要创建链表的大小:");
     
224.         scanf("%d",&iLength);
     
225. 
     
226.         p = create(iLength);
     
227.         myprint(p);
     
228. 
     
229.         printf("输入需要删除的链表位置:");
     
230.         scanf("%d",&iDelete);
     
231. 
     
232.         Node_Delete(p,iDelete);
     
233.         myprint(p);
     
234. 
     
235.         q = (stNode *)malloc(stLen);
     
236.         printf("输入需要插入的位置和姓名年龄:\n");
     
237.         scanf("%d%s%d",&iInsert,&q->sname,&q->iage);
     
238. 
     
239.         Node_Insert(p,q,iInsert);
     
240.         myprint(p);
     
241. 
     
242.         pn1 = (stNode *)malloc(stLen);
     
243.         printf("输入需要修订的链表位置和姓名年龄:\n");
     
244.         scanf("%d%s%d",&iUpdate,&pn1->sname,&pn1->iage);
     
245. 
     
246.         Node_Update(p,pn1,iUpdate);
     
247.         myprint(p);
     
248. 
     
249.         printf("现在开始逆序输出链表:\n");
     
250.         //pn2 = Node_Reverse(p);
     
251.         pn2 = Node_Reverse2(p);
     
252.         myprint(pn2);
     
253. 
     
254.         printf("开始销毁链表:\n");
     
255.         Node_Destroy(pn2);
     
256.         myprint(pn2);
     
257. 
     
258.         free(p);
     
259.         free(q);
     
260.         free(pn1);
     
261.         free(pn2);
     
262. 
     
263.         return 0;
     
264. }
     

复制代码

zsszss0000

没有看懂你的问题

MeRcy_PM

貌似有个值传递的问题，destroy没有把NULL返回给pn2，所以你的pn2还是非空，print出来还是有表在。

cobras

没有表头结构体的链表都得用二维指针来插入或者删除吧！否则，就没有下文了（直接coredump）。

cobras

我的版本。仅供参考。

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. typedef struct student
   
6. {
   
7.         char sname[10];
   
8.         int iage;
   
9.         struct student *next;
   
10. }stNode;
    
11. 
    
12. int Node_Delete(stNode **io_tab, int inum)
    
13. {
    
14.         stNode **node, *temp;
    
15. 
    
16.         if (io_tab != NULL && inum >= 0) {
    
17.                 node = io_tab;
    
18.                 while (*node != NULL) {
    
19.                         if (inum == 0) {
    
20.                                 temp = *node;
    
21.                                 *node = (*node)->next;
    
22.                                 free(temp);
    
23.                                 return 0;
    
24.                         }
    
25.                         node = &(*node)->next;
    
26.                         --inum;
    
27.                 }
    
28.         }
    
29.         return -1;
    
30. }
    
31. 
    
32. int Node_Insert(stNode **io_tab, const char sname[10], int iage, stNode **o_node)
    
33. {
    
34.         stNode *node, *temp;
    
35. 
    
36.         if (io_tab != NULL && sname != NULL) {
    
37.                 /* get the last node */
    
38.                 node = *io_tab;
    
39.                 if (node != NULL) {
    
40.                         while (node->next != NULL) {
    
41.                                 node = node->next;
    
42.                         }
    
43.                 }
    
44.                 /* append a new node */
    
45.                 temp = (stNode *)malloc(sizeof(stNode));
    
46.                 if (temp != NULL) {
    
47.                         memset(temp, 0, sizeof(stNode));
    
48.                         strncpy(temp->sname, sname, 10);
    
49.                         temp->iage = iage;
    
50.                         if (node == NULL) {
    
51.                                 *io_tab = temp;
    
52.                         }else {
    
53.                                 node->next = temp;
    
54.                         }
    
55.                         if (o_node != NULL) {
    
56.                                 *o_node = temp;
    
57.                         }
    
58.                         return 0;
    
59.                 }
    
60.         }
    
61.         return -1;
    
62. }
    
63. 
    
64. int Node_Update(stNode *tab, int inum, const char sname[10], int iage)
    
65. {
    
66.         if (tab != NULL && inum >= 0 && sname != NULL) {
    
67.                 while (tab != NULL) {
    
68.                         if (inum == 0) {
    
69.                                 strncpy(tab->sname, sname, 10);
    
70.                                 tab->iage = iage;
    
71.                                 return 0;
    
72.                         }
    
73.                         tab = tab->next;
    
74.                         --inum;
    
75.                 }
    
76.         }
    
77.         return -1;
    
78. }
    
79. 
    
80. int Node_Destroy(stNode **io_tab)
    
81. {
    
82.         stNode *node, *temp;
    
83. 
    
84.         if (io_tab != NULL) {
    
85.                 node = *io_tab;
    
86.                 while (node != NULL) {
    
87.                         temp = node;
    
88.                         node = node->next;
    
89.                         free(temp);
    
90.                 }
    
91.                 *io_tab = NULL;
    
92.                 return 0;
    
93.         }
    
94.         return -1;
    
95. }
    
96. 
    
97. int Node_Reverse(stNode **io_tab)
    
98. {
    
99.         stNode *tab, *node, *temp;
    
100. 
     
101.         if (io_tab != NULL) {
     
102.                 tab = NULL;
     
103.                 node = *io_tab;
     
104.                 while (node != NULL) {
     
105.                         temp = node;
     
106.                         node = node->next;
     
107.                         temp->next = tab;
     
108.                         tab = temp;
     
109.                 }
     
110.                 *io_tab = tab;
     
111.                 return 0;
     
112.         }
     
113.         return -1;
     
114. }
     
115. 
     
116. int myprint(stNode *tab)
     
117. {
     
118.         int cnt;
     
119. 
     
120.         cnt = 0;
     
121.         while(tab != NULL) {
     
122.                 printf("%d: name->[%.*s],age->[%d]\n", cnt, 10, tab->sname, tab->iage);
     
123.                 tab = tab->next;
     
124.                 ++cnt;
     
125.         }
     
126.         return 0;
     
127. }
     
128. 
     
129. int main(void)
     
130. {
     
131.         char sname[10];
     
132.         int iage;
     
133.         stNode *tab;
     
134.         int iLength = 0;
     
135.         int iDelete = 0;
     
136.         int iInsert = 0;
     
137.         int iUpdate = 0;
     
138. 
     
139.         tab = NULL;
     
140. 
     
141.         printf("开始创建链表\n");
     
142.         printf("输入需要创建链表的大小: ");
     
143.         scanf("%d", &iLength);
     
144.         while (iLength-- > 0) {
     
145.                 Node_Insert(&tab, "<null>", iLength, NULL);
     
146.         }
     
147.         myprint(tab);
     
148. 
     
149.         printf("输入需要删除的链表位置: ");
     
150.         scanf("%d", &iDelete);
     
151.         Node_Delete(&tab, iDelete);
     
152.         myprint(tab);
     
153. 
     
154.         printf("输入需要插入的姓名和年龄:\n");
     
155.         scanf("%s%d", sname, &iage);
     
156.         Node_Insert(&tab, sname, iage, NULL);
     
157.         myprint(tab);
     
158. 
     
159.         printf("输入需要修订的链表位置和姓名年龄:\n");
     
160.         scanf("%d%s%d", &iUpdate, sname, &iage);
     
161.         Node_Update(tab, iUpdate, sname, iage);
     
162.         myprint(tab);
     
163. 
     
164.         printf("现在开始逆序输出链表:\n");
     
165.         Node_Reverse(&tab);
     
166.         myprint(tab);
     
167. 
     
168.         printf("开始销毁链表:\n");
     
169.         Node_Destroy(&tab);
     
170.         myprint(tab);
     
171.        
     
172.         return 0;
     
173. }
     

复制代码

lwphappy

回复 5# cobras
前段时间比较忙,没来得及回复,不好意思,多谢帮助,等下去试试你的方法