为什么我执行完destroy函数会出现这个框？？

愿你

销毁到底是什么意思？
执行销毁之后，正常程序应该出现什么情况？
# include<stdio.h>
# include<stdlib.h>

typedef struct LNode{
        int data;
        struct LNode *next;
}LNode,*Linklist;

void initlist(Linklist *L)
{
        (*L)=(Linklist)malloc(sizeof(LNode));
        if(!(*L))
                printf("对不起，无法进行地址分配哦~\n");
        (*L)->next=*L;
        printf("初始化成功 ~\n");
}

void creatlist(Linklist *L)//尾插法
{
        int n,i;
        Linklist r;//指向尾节点
        r=*L;
        printf("请输入需要的元素个数：");
        scanf("%d",&n);
        for(i=0;i<n;i++)
        {
                Linklist p=malloc(sizeof(LNode));
                if(!p)
                        printf("对不起，无法正常分配空间哦\n");
                else
                {
                        printf("请输入第%d个元素",i+1);
                        scanf("%d",&p->data);
                        p->next=*L;
                        r->next=p;
                        r=p;
                }
        }
}


void showlist(Linklist *L)
{
        Linklist p;
        p=(*L)->next;
        if((*L)->next==*L)
                printf("循环链表中没有元素哦，无法显示。\n");
        else
        {
                while(p!=(*L))
                {
                        printf("%d ",p->data);
                        p=p->next;
                }
        }
        printf("\n");
}

void destroylist(Linklist *L)
{
        Linklist p;
        while(*L)
        {
                p=(*L)->next;
                free(*L);
                *L=p;
        }
}

void lengthlist(Linklist *L)
{
        Linklist p;
        int length=0;
        p=(*L)->next;
        while(p!=(*L))
        {
                length++;
                p=p->next;
        }
        printf("您的循环链表长度为%d\n",length);
}


int main()
{
        Linklist L;
        initlist(&L);
        creatlist(&L);
        showlist(&L);
        lengthlist(&L);
        destroylist(&L);
        showlist(&L);
        return 0;
}

BngThea

目测是删了未分配的椎空间

愿你

BngThea 发表于 2018-4-2 09:54
目测是删了未分配的椎空间

可是销毁不就是要把从头到尾把每一个结点都释放掉吗？？

BngThea

是不是你的链表尾部不为NULL？

人造人

多了一个 -842150451 吧，那么请问 -842150451 从何而来？

愿你

BngThea 发表于 2018-4-2 11:06
是不是你的链表尾部不为NULL？

我是循环链表，尾部不是应该指向头结点吗

愿你

人造人 发表于 2018-4-2 11:58
多了一个 -842150451 吧，那么请问 -842150451 从何而来？

这个842150451是什么东西....

人造人

愿你 发表于 2018-4-2 15:48
这个842150451是什么东西....

愿你

人造人 发表于 2018-4-2 15:56

可是头结点的数据域不是可以不写吗
销毁不是从头结点一个一个销毁吗

BngThea

愿你 发表于 2018-4-2 15:47
我是循环链表，尾部不是应该指向头结点吗

原来你的头节点根本没放数据，怎么能free

愿你

BngThea 发表于 2018-4-2 16:09
原来你的头节点根本没放数据，怎么能free

为什么没有数据就不可以free。

人造人

愿你 发表于 2018-4-2 16:13
为什么没有数据就不可以free。

好吧，和1234没有任何关系，以后不要写这种让人误解的代码，头结点的数据域没有初始化，我的本能告诉我这里有问题^_^，其实这个问题不会导致这个程序崩溃，其他的我就不保证了，所以，还是尽量把改初始化的都初始化了





好了，现在来看看你程序的问题
请问，什么时候while循环会停止？
也就是说*L什么时候会是0 ？
0表示假，0会使while循环停止
那么，什么时候*L会是0 ？

愿你

人造人 发表于 2018-4-2 16:42
好吧，和1234没有任何关系，以后不要写这种让人误解的代码，头结点的数据域没有初始化，我的本能告 ...

这个问题把我难住了
因为是循环链表，所以我不可以先释放头结点？因为如果我先释放头结点，我尾节点是指向头结点的，那么我找不到终止循环的条件
是这样吗

人造人

愿你 发表于 2018-4-2 20:35
这个问题把我难住了
因为是循环链表，所以我不可以先释放头结点？因为如果我先释放头结点， ...

1. # include<stdio.h>
   
2. # include<stdlib.h>
   
3. 
   
4. typedef struct LNode {
   
5.         int data;
   
6.         struct LNode *next;
   
7. }LNode, *Linklist;
   
8. 
   
9. void initlist(Linklist *L)
   
10. {
    
11.         (*L) = (Linklist)malloc(sizeof(LNode));
    
12.         if(!(*L))
    
13.                 printf("对不起，无法进行地址分配哦~\n");
    
14.         (*L)->next = *L;
    
15.         printf("初始化成功 ~\n");
    
16. 
    
17.         (*L)->data = 1234;
    
18. }
    
19. 
    
20. void creatlist(Linklist *L)//尾插法
    
21. {
    
22.         int n, i;
    
23.         Linklist r;//指向尾节点
    
24.         r = *L;
    
25.         printf("请输入需要的元素个数：");
    
26.         scanf("%d", &n);
    
27.         for(i = 0; i<n; i++)
    
28.         {
    
29.                 Linklist p = malloc(sizeof(LNode));
    
30.                 if(!p)
    
31.                         printf("对不起，无法正常分配空间哦\n");
    
32.                 else
    
33.                 {
    
34.                         printf("请输入第%d个元素", i + 1);
    
35.                         scanf("%d", &p->data);
    
36.                         p->next = *L;
    
37.                         r->next = p;
    
38.                         r = p;
    
39.                 }
    
40.         }
    
41. }
    
42. 
    
43. 
    
44. void showlist(Linklist *L)
    
45. {
    
46.         Linklist p;
    
47.         p = (*L)->next;
    
48.         if((*L)->next == *L)
    
49.                 printf("循环链表中没有元素哦，无法显示。\n");
    
50.         else
    
51.         {
    
52.                 while(p != (*L))
    
53.                 {
    
54.                         printf("%d ", p->data);
    
55.                         p = p->next;
    
56.                 }
    
57.         }
    
58.         printf("\n");
    
59. }
    
60. 
    
61. int lengthlist(Linklist *L)
    
62. {
    
63.         Linklist p;
    
64.         int length = 0;
    
65.         p = (*L)->next;
    
66.         while(p != (*L))
    
67.         {
    
68.                 length++;
    
69.                 p = p->next;
    
70.         }
    
71.         printf("您的循环链表长度为%d\n", length);
    
72. 
    
73.         return length;
    
74. }
    
75. 
    
76. void destroylist(Linklist *L)
    
77. {
    
78.         Linklist p;
    
79. 
    
80.         int len = lengthlist(L);
    
81.         for(int i = 0; i < len + 1; ++i)
    
82.         {
    
83.                 p = (*L)->next;
    
84.                 free(*L);
    
85.                 *L = p;
    
86.         }
    
87. }
    
88. 
    
89. int main()
    
90. {
    
91.         Linklist L;
    
92.         initlist(&L);
    
93.         creatlist(&L);
    
94.         showlist(&L);
    
95.         lengthlist(&L);
    
96.         destroylist(&L);
    
97.         //showlist(&L);
    
98.         return 0;
    
99. }

复制代码

愿你

人造人 发表于 2018-4-2 20:48

我照你的程序代码改了
可是程序还是停止工作
void destroylist(Linklist *L)  //销毁链表
{
        Linklist p;
        int len=lengthlist(&L);
        int i;
        for(i=0;i<len;i++)
        {
                p=(*L)->next;
                free(*L);
                *L=p;
        }
}

int lengthlist(Linklist *L) //求链表长度
{
        Linklist p;
        int length=0;
        p=(*L)->next;
        while(p!=(*L))
        {
                length++;
                p=p->next;
        }
        printf("您的循环链表长度为%d\n",length);
        return length;
}

愿你

人造人 发表于 2018-4-2 20:48

我才发现论坛有这个功能

1. void destroylist(Linklist *L)  //销毁链表
   
2. {
   
3.         Linklist p;
   
4.         int len=lengthlist(&L);
   
5.         int i;
   
6.         for(i=0;i<len;i++)
   
7.         {
   
8.                 p=(*L)->next;
   
9.                 free(*L);
   
10.                 *L=p;
    
11.         }
    
12. }
    
13. 
    
14. int lengthlist(Linklist *L) //求链表长度
    
15. {
    
16.         Linklist p;
    
17.         int length=0;
    
18.         p=(*L)->next;
    
19.         while(p!=(*L))
    
20.         {
    
21.                 length++;
    
22.                 p=p->next;
    
23.         }
    
24.         printf("您的循环链表长度为%d\n",length);
    
25.         return length;
    
26. }
    

复制代码

人造人

愿你 发表于 2018-4-2 22:13
我才发现论坛有这个功能

发完整代码

愿你

人造人 发表于 2018-4-3 08:36
发完整代码

我把destroy函数改了下，但还是会出现程序停止运行的框
那究竟怎么样才算程序已经把销毁工作完成？？

1. # include<stdio.h>
   
2. # include<stdlib.h>
   
3. 
   
4. typedef struct LNode{
   
5.         int data;
   
6.         struct LNode *next;
   
7. }LNode,*Linklist;
   
8. 
   
9. void initlist(Linklist *L) //初始化链表
   
10. {
    
11.         (*L)=(Linklist)malloc(sizeof(LNode));
    
12.         if(!(*L))
    
13.                 printf("对不起，无法进行地址分配哦~\n");
    
14.         (*L)->next=*L;
    
15.         printf("初始化成功 ~\n");
    
16. }
    
17. 
    
18. void creatlist(Linklist *L)//尾插法创建链表
    
19. {
    
20.         int n,i;
    
21.         Linklist r;//指向尾节点
    
22.         r=*L;
    
23.         printf("请输入需要的元素个数：");
    
24.         scanf("%d",&n);
    
25.         for(i=0;i<n;i++)
    
26.         {
    
27.                 Linklist p=malloc(sizeof(LNode));
    
28.                 if(!p)
    
29.                         printf("对不起，无法正常分配空间哦\n");
    
30.                 else
    
31.                 {
    
32.                         printf("请输入第%d个元素",i+1);
    
33.                         scanf("%d",&p->data);
    
34.                         p->next=*L;
    
35.                         r->next=p;
    
36.                         r=p;
    
37.                 }
    
38.         }
    
39. }
    
40. 
    
41. 
    
42. void showlist(Linklist *L) //显示链表
    
43. {
    
44.         Linklist p;
    
45.         p=(*L)->next;
    
46.         if((*L)->next==*L)
    
47.                 printf("循环链表中没有元素哦，无法显示。\n");
    
48.         else
    
49.         {
    
50.                 while(p!=(*L))
    
51.                 {
    
52.                         printf("%d ",p->data);
    
53.                         p=p->next;
    
54.                 }
    
55.         }
    
56.         printf("\n");
    
57. }
    
58. 
    
59. /*void destroylist(Linklist *L)  //销毁链表
    
60. {
    
61.         Linklist p;
    
62.         int len=lengthlist(&L);
    
63.         int i;
    
64.         for(i=0;i<len;i++)
    
65.         {
    
66.                 p=(*L)->next;
    
67.                 free(*L);
    
68.                 *L=p;
    
69.         }
    
70.         printf("您的链表已被销毁~\n");
    
71. }*/
    
72. 
    
73. int destroylist(Linklist *L)
    
74. {
    
75.         Linklist p,pnext,p1=(*L)->next;
    
76.         for(p=p1;p->next!=p1;p=pnext)
    
77.         {
    
78.                 pnext=p->next;
    
79.                 free(p);
    
80.         }
    
81.         free(*L);
    
82.         printf("您的链表已被销毁~\n");
    
83.         return 0;
    
84. }
    
85. 
    
86. 
    
87. 
    
88. 
    
89. 
    
90. 
    
91. 
    
92. 
    
93. 
    
94. 
    
95. 
    
96. 
    
97. int lengthlist(Linklist *L) //求链表长度
    
98. {
    
99.         Linklist p;
    
100.         int length=0;
     
101.         p=(*L)->next;
     
102.         while(p!=(*L))
     
103.         {
     
104.                 length++;
     
105.                 p=p->next;
     
106.         }
     
107.         printf("您的循环链表长度为%d\n",length);
     
108.         return length;
     
109. }
     
110. 
     
111. void clearlist(Linklist *L)  //清空链表
     
112. {
     
113.         Linklist p,q;
     
114.         p=(*L)->next;
     
115.         while(p!=(*L))
     
116.         {
     
117.                 q=p->next;
     
118.                 free(p);
     
119.                 p=q;
     
120.         }
     
121.         p->next=(*L);
     
122. }
     
123. 
     
124. void isempty(Linklist *L) //判断表是否为空
     
125. {
     
126.         if((*L)->next==(*L))
     
127.                 printf("该链表为空\n");
     
128.         else
     
129.                 printf("该链表不为空~\n");
     
130. }
     
131. 
     
132. 
     
133. void locateelemlist(Linklist *L) //根据元素内容判断元素位置
     
134. {
     
135.         int e,i=0;
     
136.         Linklist p;
     
137.         printf("请输入您想要查询的元素内容：");
     
138.         scanf("%d",&e);
     
139.         p=(*L)->next;
     
140.         if((*L)->next==*L)
     
141.                 printf("循环链表中没有元素哦，无法查询。\n");
     
142.         while(p->next!=(*L))
     
143.         {
     
144.                 i++;
     
145.                 if(p->data==e)
     
146.                         printf("您查询的元素内容%d是第%d号元素\n",e,i);
     
147.                 p=p->next;
     
148.         }
     
149. }
     
150. 
     
151. void getelemlist(Linklist *L) //根据元素位置查找元素内容。
     
152. {
     
153.         int i=0,e,j;
     
154.         Linklist p=(*L)->next;
     
155.         printf("请输入您想要查询的元素位置：");
     
156.         scanf("%d",&j);
     
157.         if((*L)->next==*L)
     
158.                 printf("循环链表中没有元素哦，无法查询。\n");
     
159.         else
     
160.         {
     
161.                 while(p!=(*L))
     
162.                 {
     
163.                         i++;
     
164.                         if(i==j)
     
165.                         {
     
166.                                 e=p->data;
     
167.                                 printf("您所要查询的位置的元素内容为%d\n",e);
     
168.                                 break;
     
169.                         }
     
170.                         p=p->next;
     
171.                 }
     
172.                 if(i!=j)
     
173.                         printf("尚未查询到您所需要的元素。\n");
     
174.         }
     
175. }
     
176. 
     
177. void insertlist(Linklist *L)  //将指定的元素位置之前插入一个元素
     
178. {
     
179.         int j,i,e;
     
180.         Linklist p,s;
     
181.         p=*L;       
     
182.         j=0;
     
183.         printf("请输入您想要在几号元素之前插入什么元素内容");
     
184.         scanf("%d,%d",&i,&e);
     
185.         while(p->next!=(*L)&&j<i-1)
     
186.         {
     
187.                 p=p->next;
     
188.                 j++;
     
189.         }
     
190.         if(!p||j>i-1)
     
191.                 printf("对不起插入位置有误。\n");
     
192.         else
     
193.         {
     
194.                 s=(Linklist)malloc(sizeof(LNode));
     
195.                 s->data=e;
     
196.                 s->next=p->next;
     
197.                 p->next=s;
     
198.         }
     
199. }
     
200. 
     
201. void deletelist(Linklist *L)
     
202. {
     
203.         int i,j;
     
204.         Linklist p,q;
     
205.         p=*L;
     
206.         j=0;
     
207.         printf("请问您想要在删除哪一号元素：");
     
208.         scanf("%d",&i);
     
209.         while(p->next!=(*L)&&j<i-1)
     
210.         {
     
211.                 p=p->next;
     
212.                 j++;
     
213.         }
     
214.         if(!p&&j>i-1)
     
215.                 printf("对不起删除位置有误\n");
     
216.         else
     
217.         {
     
218.                 q=p->next;
     
219.                 p->next=q->next;
     
220.         }
     
221. }
     
222. 
     
223. 
     
224. 
     
225. 
     
226. 
     
227. 
     
228. int main()
     
229. {
     
230.         Linklist L;
     
231.         initlist(&L);
     
232.         creatlist(&L);
     
233.         showlist(&L);
     
234.         lengthlist(&L);
     
235.         destroylist(&L);
     
236.         //locateelemlist(&L);
     
237.         lengthlist(&L);
     
238.         showlist(&L);
     
239.         //getelemlist(&L);
     
240.         /*insertlist(&L);
     
241.         showlist(&L);
     
242.         deletelist(&L);
     
243.         showlist(&L);
     
244.         clearlist(&L);
     
245.         showlist(&L);*/
     
246.         return 0;
     
247. }

复制代码

人造人

愿你 发表于 2018-4-3 20:16
我把destroy函数改了下，但还是会出现程序停止运行的框
那究竟怎么样才算程序已经把销毁工作完成？？

...

1. # include<stdio.h>
   
2. # include<stdlib.h>
   
3. 
   
4. typedef struct LNode {
   
5.         int data;
   
6.         struct LNode *next;
   
7. }LNode, *Linklist;
   
8. 
   
9. void initlist(Linklist *L) //初始化链表
   
10. {
    
11.         (*L) = (Linklist)malloc(sizeof(LNode));
    
12.         if(!(*L))
    
13.                 printf("对不起，无法进行地址分配哦~\n");
    
14.         (*L)->next = *L;
    
15.         printf("初始化成功 ~\n");
    
16. 
    
17. 
    
18.         (*L)->data = 1234;        // debug
    
19. }
    
20. 
    
21. void creatlist(Linklist *L)//尾插法创建链表
    
22. {
    
23.         int n, i;
    
24.         Linklist r;//指向尾节点
    
25.         r = *L;
    
26.         printf("请输入需要的元素个数：");
    
27.         scanf("%d", &n);
    
28.         for(i = 0; i<n; i++)
    
29.         {
    
30.                 Linklist p = malloc(sizeof(LNode));
    
31.                 if(!p)
    
32.                         printf("对不起，无法正常分配空间哦\n");
    
33.                 else
    
34.                 {
    
35.                         printf("请输入第%d个元素", i + 1);
    
36.                         scanf("%d", &p->data);
    
37.                         p->next = *L;
    
38.                         r->next = p;
    
39.                         r = p;
    
40.                 }
    
41.         }
    
42. }
    
43. 
    
44. 
    
45. void showlist(Linklist *L) //显示链表
    
46. {
    
47.         if(*L == NULL)
    
48.                 return -1;
    
49. 
    
50.         Linklist p;
    
51.         p = (*L)->next;
    
52.         if((*L)->next == *L)
    
53.                 printf("循环链表中没有元素哦，无法显示。\n");
    
54.         else
    
55.         {
    
56.                 while(p != (*L))
    
57.                 {
    
58.                         printf("%d ", p->data);
    
59.                         p = p->next;
    
60.                 }
    
61.         }
    
62.         printf("\n");
    
63. }
    
64. 
    
65. /*void destroylist(Linklist *L)  //销毁链表
    
66. {
    
67. Linklist p;
    
68. int len=lengthlist(&L);
    
69. int i;
    
70. for(i=0;i<len;i++)
    
71. {
    
72. p=(*L)->next;
    
73. free(*L);
    
74. *L=p;
    
75. }
    
76. printf("您的链表已被销毁~\n");
    
77. }*/
    
78. 
    
79. int destroylist(Linklist *L)
    
80. {
    
81.         Linklist p, pnext, p1 = (*L)->next;
    
82.         for(p = p1; p->next != p1; p = pnext)
    
83.         {
    
84.                 pnext = p->next;
    
85.                 free(p);
    
86.         }
    
87.         free(*L);
    
88.         printf("您的链表已被销毁~\n");
    
89. 
    
90.         *L = NULL;
    
91. 
    
92.         return 0;
    
93. }
    
94. 
    
95. 
    
96. 
    
97. 
    
98. 
    
99. 
    
100. 
     
101. 
     
102. 
     
103. 
     
104. 
     
105. 
     
106. int lengthlist(Linklist *L) //求链表长度
     
107. {
     
108.         if(*L == NULL)
     
109.                 return -1;
     
110. 
     
111.         Linklist p;
     
112.         int length = 0;
     
113.         p = (*L)->next;
     
114.         while(p != (*L))
     
115.         {
     
116.                 length++;
     
117.                 p = p->next;
     
118.         }
     
119.         printf("您的循环链表长度为%d\n", length);
     
120.         return length;
     
121. }
     
122. 
     
123. void clearlist(Linklist *L)  //清空链表
     
124. {
     
125.         Linklist p, q;
     
126.         p = (*L)->next;
     
127.         while(p != (*L))
     
128.         {
     
129.                 q = p->next;
     
130.                 free(p);
     
131.                 p = q;
     
132.         }
     
133.         p->next = (*L);
     
134. }
     
135. 
     
136. void isempty(Linklist *L) //判断表是否为空
     
137. {
     
138.         if((*L)->next == (*L))
     
139.                 printf("该链表为空\n");
     
140.         else
     
141.                 printf("该链表不为空~\n");
     
142. }
     
143. 
     
144. 
     
145. void locateelemlist(Linklist *L) //根据元素内容判断元素位置
     
146. {
     
147.         int e, i = 0;
     
148.         Linklist p;
     
149.         printf("请输入您想要查询的元素内容：");
     
150.         scanf("%d", &e);
     
151.         p = (*L)->next;
     
152.         if((*L)->next == *L)
     
153.                 printf("循环链表中没有元素哦，无法查询。\n");
     
154.         while(p->next != (*L))
     
155.         {
     
156.                 i++;
     
157.                 if(p->data == e)
     
158.                         printf("您查询的元素内容%d是第%d号元素\n", e, i);
     
159.                 p = p->next;
     
160.         }
     
161. }
     
162. 
     
163. void getelemlist(Linklist *L) //根据元素位置查找元素内容。
     
164. {
     
165.         int i = 0, e, j;
     
166.         Linklist p = (*L)->next;
     
167.         printf("请输入您想要查询的元素位置：");
     
168.         scanf("%d", &j);
     
169.         if((*L)->next == *L)
     
170.                 printf("循环链表中没有元素哦，无法查询。\n");
     
171.         else
     
172.         {
     
173.                 while(p != (*L))
     
174.                 {
     
175.                         i++;
     
176.                         if(i == j)
     
177.                         {
     
178.                                 e = p->data;
     
179.                                 printf("您所要查询的位置的元素内容为%d\n", e);
     
180.                                 break;
     
181.                         }
     
182.                         p = p->next;
     
183.                 }
     
184.                 if(i != j)
     
185.                         printf("尚未查询到您所需要的元素。\n");
     
186.         }
     
187. }
     
188. 
     
189. void insertlist(Linklist *L)  //将指定的元素位置之前插入一个元素
     
190. {
     
191.         int j, i, e;
     
192.         Linklist p, s;
     
193.         p = *L;
     
194.         j = 0;
     
195.         printf("请输入您想要在几号元素之前插入什么元素内容");
     
196.         scanf("%d,%d", &i, &e);
     
197.         while(p->next != (*L) && j<i - 1)
     
198.         {
     
199.                 p = p->next;
     
200.                 j++;
     
201.         }
     
202.         if(!p || j>i - 1)
     
203.                 printf("对不起插入位置有误。\n");
     
204.         else
     
205.         {
     
206.                 s = (Linklist)malloc(sizeof(LNode));
     
207.                 s->data = e;
     
208.                 s->next = p->next;
     
209.                 p->next = s;
     
210.         }
     
211. }
     
212. 
     
213. void deletelist(Linklist *L)
     
214. {
     
215.         int i, j;
     
216.         Linklist p, q;
     
217.         p = *L;
     
218.         j = 0;
     
219.         printf("请问您想要在删除哪一号元素：");
     
220.         scanf("%d", &i);
     
221.         while(p->next != (*L) && j<i - 1)
     
222.         {
     
223.                 p = p->next;
     
224.                 j++;
     
225.         }
     
226.         if(!p&&j>i - 1)
     
227.                 printf("对不起删除位置有误\n");
     
228.         else
     
229.         {
     
230.                 q = p->next;
     
231.                 p->next = q->next;
     
232.         }
     
233. }
     
234. 
     
235. 
     
236. 
     
237. 
     
238. 
     
239. 
     
240. int main()
     
241. {
     
242.         Linklist L;
     
243.         initlist(&L);
     
244.         creatlist(&L);
     
245.         showlist(&L);
     
246.         lengthlist(&L);
     
247.         destroylist(&L);
     
248.         //locateelemlist(&L);
     
249.         lengthlist(&L);
     
250.         showlist(&L);
     
251.         //getelemlist(&L);
     
252.         /*insertlist(&L);
     
253.         showlist(&L);
     
254.         deletelist(&L);
     
255.         showlist(&L);
     
256.         clearlist(&L);
     
257.         showlist(&L);*/
     
258.         return 0;
     
259. }
     

复制代码