清空链表跟销毁链表的区别

链表是一个很基本的数据结构，其他的数据结构（如：栈、队列、二叉树等）都可以用链表来实现。

销毁：是先销毁了链表的头，然后接着一个一个的把后面的销毁了，这样这个链表就不能再使用了，即把包括头的所有节点全部释放。

清空：是先保留了链表的头，然后把头后面的所有的都销毁，最后把头里指向下一个的指针设为空，这样就相当与清空了，但这个链表还在，还可以继续使用；即保留了头，后面的全部释放。

清空是链表的头还在，可以继续插入节点；销毁就是链表没了，整个链表(包括头)的空间都被释放了，不能进行任何操作了。

---链表有很多种，以下均指的是不带头结点的单向链表。

清空链表与销毁链表的代码如下：

[cpp]  view plain copy

1. #include "stdlib.h"  
2. #include "stdio.h"  
3.   
4. struct student  
5. {  
6.     int num;              //学号   
7.     float score;          //分数，其他信息可以继续在下面增加字段  
8.     struct student *next;       //指向下一节点的指针  
9. };  
10.   
11. //销毁链表  
12. int DestroyList(struct student *head)  
13. {  
14.     struct student *p;  
15.     if(head==NULL)  
16.         return 0;  
17.     while(head)  
18.     {  
19.         p=head->next;  
20.         free(head);  
21.         head=p;  
22.     }  
23.     return 1;  
24. }  
25.   
26. //清空链表  
27. int ClearList(struct student *head)  
28. {  
29.     struct student *p,*q;  
30.     if(head==NULL)  
31.         return 0;  
32.     p=head->next;  
33.     while(p!=NULL)  
34.     {  
35.         q=p->next;  
36.         free(p);  
37.         p=q;  
38.     }  
39.     head->next=NULL;  
40.     return 1;  
41. }  

2、链表相邻元素翻转，如a->b->c->d->e->f-g，翻转后变为：b->a->d->c->f->e->g
思路：常见的三指针方法

[cpp]  view plain copy

1. typedef struct LinkNode  
2. {  
3.     int data;  
4.     struct LinkNode* next;  
5. }LinkNode , *LinkList;  
6.   
7. LinkList inverseList(LinkList head)  
8. {  
9.     if(head == NULL || head->next == NULL)  
10.         return head;  
11.     LinkList pre = NULL;  
12.     LinkList curr = head;  
13.     LinkList next = NULL;  
14.   
15.     while(curr && curr->next)  
16.     {  
17.         if(pre)  
18.             pre->next = curr->next;  
19.         else  
20.             head = curr->next;  
21.   
22.         pre = curr;  
23.         next = curr->next->next;  
24.         curr->next->next = curr;  
25.         curr->next = next;  
26.         curr = next;