第四周项目三 单链表应用-结点逆置

问题及代码：

1. /*    
2. *烟台大学计算机与控制工程学院     
3. *作    者：申鹏鹏
   
4. *完成日期：2016年9月24日 
5. *问题描述:设计一个算法，将一个带头结点的数据域依次为a1，a2，…，an（n≥3）的单链表的所有结点逆置，即第一个结点的数据域变为an，…，最后一个结点的数据域为a1。实现这个算法，并完成测试。  
6. */
7. 
   1、list.h的代码：
8. 1. #include <stdio.h>  
   2. #include <malloc.h>  
   3. typedef int ElemType;  
   4. typedef struct LNode        //定义单链表结点类型  
   5. {  
   6.     ElemType data;  
   7.     struct LNode *next;     //指向后继结点  
   8. }LinkList;  
   9. void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表  
   10. void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表  
   11. void InitList(LinkList *&L);  //初始化线性表  
   12. void DestroyList(LinkList *&L);  //销毁线性表  
   13. bool ListEmpty(LinkList *L);  //判断线性表是否为空  
   14. int ListLength(LinkList *L);  //求线性表长度  
   15. void DispList(LinkList *L);  //输出线性表  
   16. bool GetElem(LinkList *L,int i,ElemType &e);  //求线性表某个数据元素值  
   17. int LocateElem(LinkList *L,ElemType e);  //按元素值查找  
   18. bool ListInsert(LinkList *&L,int i,ElemType e);  //插入数据元素  
   19. bool ListDelete(LinkList *&L,int i,ElemType &e);  //删除数据元素  
   20. void Reverse(LinkList *&L);
   2、list.cpp的代码：
9. 1. #include"list.h"  
   2. void CreateListF(LinkList *&L,ElemType a[],int n)//头插法建立单链表  
   3. {  
   4.     LinkList *s;  
   5.     int i;  
   6.     L=(LinkList *)malloc(sizeof(LinkList));  
   7.     L->next=NULL;//创建头结点，其next域为NULL  
   8.     for(i=0;i<n;i++)  
   9.     {  
   10.         s=(LinkList *)malloc(sizeof(LinkList));  
   11.         s->data=a[i];//创建数据节点*s  
   12.         s->next=L->next;  
   13.         L->next=s;  
   14.     }  
   15. }  
   16. void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法建立单链表  
   17. {  
   18.         LinkList *s,*r;  
   19.         int i;  
   20.         L=(LinkList *)malloc(sizeof(LinkList));  
   21.         r=L;  
   22.         for(i=0;i<n;i++)  
   23.         {  
   24.             s=(LinkList *)malloc(sizeof(LinkList));  
   25.             s->data=a[i];//创建数据节点*s  
   26.             r->next=s;//将*s插在*r之后  
   27.             r=s;  
   28.         }  
   29.         r->next=NULL;  
   30. }  
   31.   
   32.   
   33.   
   34.   
   35. void InitList(LinkList *&L) //初始化线性表  
   36. {  
   37.     L=(LinkList *)malloc(sizeof(LinkList));  
   38.     L->next=NULL;  
   39. }  
   40. void DestroyList(LinkList *&L)//销毁线性表  
   41. {  
   42.     LinkList *p=L,*q=p->next;  
   43.     while (q!=NULL)  
   44.     {  
   45.         free(p);  
   46.         p=q;  
   47.         q=p->next;  
   48.     }  
   49.     free(p);    //此时q为NULL,p指向尾结点,释放它  
   50. }  
   51. bool ListEmpty(LinkList *L)  //判断线性表是否为空  
   52. {  
   53.     return(L->next==NULL);  
   54. }  
   55. int ListLength(LinkList *L) //求线性表长度  
   56. {  
   57.     int n=0;  
   58.     LinkList *p=L;  
   59.     while(p->next!=NULL)  
   60.     {  
   61.         n++;  
   62.         p=p->next;  
   63.     }  
   64.     return (n);  
   65. }  
   66.   
   67. bool GetElem(LinkList *L,int i,ElemType &e)  //求线性表某个数据元素值  
   68. {  
   69.     int j=0;  
   70.     LinkList *p=L;  
   71.     while(j<i&&p!=NULL)  
   72.     {  
   73.         j++;  
   74.         p->next;  
   75.     }  
   76.     if(p==NULL)  
   77.         return false;  
   78.     else  
   79.     {  
   80.         e=p->data;  
   81.         return true;  
   82.     }  
   83. }  
   84.   
   85. int LocateElem(LinkList *L,ElemType e)  //按元素值查找  
   86. {  
   87.     int i=1;  
   88.     LinkList *p=L->next;  
   89.     while(p!=NULL&&p->data!=e)  
   90.     {  
   91.         p=p->next;  
   92.         i++;  
   93.     }  
   94.     if(p==NULL)  
   95.         return (0);  
   96.     else  
   97.         return(i);  
   98. }  
   99.   
   100. bool ListInsert(LinkList *&L,int i,ElemType e)  //插入数据元素  
   101. {  
   102.     int j=0;  
   103.     LinkList *p=L,*s;//p指向头结点，j置为0  
   104.     while(j<i-1&&p!=NULL)  
   105.     {  
   106.         j++;  
   107.         p=p->next;  
   108.     }  
   109.     if(p==NULL)  
   110.         return false;  
   111.     else  
   112.     {  
   113.         s=(LinkList *)malloc(sizeof(LinkList));  
   114.         s->data=e;  
   115.         s->next=p->next;  
   116.         p->next=s;  
   117.         return true;  
   118.     }  
   119. }  
   120.   
   121. bool ListDelete(LinkList *&L,int i,ElemType &e)  //删除数据元素  
   122. {  
   123.     int j=0;  
   124.     LinkList *p=L,*q;  
   125.     while(j<i-1&&p!=NULL)  
   126.     {  
   127.         j++;  
   128.         p=p->next;  
   129.     }  
   130.     if(p==NULL)  
   131.         return false;  
   132.     else  
   133.     {  
   134.         q=p->next;  
   135.         if(q==NULL)  
   136.             return false;  
   137.         e=q->data;  
   138.         p->next=q->next;  
   139.         free(q);  
   140.         return true;  
   141.     }  
   142. }  
   143. void DispList(LinkList *L)  //输出单链表  
   144. {  
   145.     LinkList *p=L->next;//p开始指向节点  
   146.     while(p!=NULL)  
   147.     {  
   148.         printf("%d ",p->data);  
   149.         p=p->next;  
   150.     }  
   151.     printf("\n");  
   152. }  
   153. void Reverse(LinkList *&L)  
   154. {  
   155.     LinkList *p=L->next,*q;  
   156.     L->next=NULL;  
   157.     while (p!=NULL)     //扫描所有的结点  
   158.     {  
   159.         q=p->next;      //让q指向*p结点的下一个结点  
   160.         p->next=L->next;    //总是将*p结点作为第一个数据结点  
   161.         L->next=p;  
   162.         p=q;            //让p指向下一个结点  
   163.     }  
   164. }
   3、main函数代码：
10. 1. #include <stdio.h>  
    2. #include "list.h"  
    3. int main()  
    4. {  
    5.     LinkList *L;  
    6.     ElemType a[]={1,3,5,7,2,4,8,10};  
    7.     CreateListR(L,a,8);  
    8.     printf("L: ");  
    9.     DispList(L);  
    10.     Reverse(L);  
    11.     printf("逆置后L: ");  
    12.     DispList(L);  
    13.     DestroyList(L);  
    14.     return 0;  
    15. }
    运行结果：
11.