第四周项目三 单链表应用-连接

问题及代码：

1. /*    
2. *烟台大学计算机与控制工程学院     
3. *作    者：申鹏鹏
   
4. *完成日期：2016年9月24日 
5. *问题描述:已知L1和L2分别指向两个单链表的头结点，且已知其长度分别为m、n，请设计算法将L2连接到L1的后面。实现这个算法，完成测试，并分析这个算法的复杂度。 
6. */
7. 1、list.h的代码：
8. 1. #ifndef LINKLIST_H_INCLUDED  
   2. #define LINKLIST_H_INCLUDED
   3. #include <stdio.h>  
   4. #include <malloc.h>  
   5. typedef int ElemType;  
   6. typedef struct LNode        //定义单链表结点类型  
   7. {  
   8.     ElemType data;  
   9.     struct LNode *next;     //指向后继结点  
   10. }LinkList;  
   11. void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表  
   12. void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表  
   13. void InitList(LinkList *&L);  //初始化线性表  
   14. void DestroyList(LinkList *&L);  //销毁线性表  
   15. bool ListEmpty(LinkList *L);  //判断线性表是否为空  
   16. int ListLength(LinkList *L);  //求线性表长度  
   17. void DispList(LinkList *L);  //输出线性表  
   18. bool GetElem(LinkList *L,int i,ElemType &e);  //求线性表某个数据元素值  
   19. int LocateElem(LinkList *L,ElemType e);  //按元素值查找  
   20. bool ListInsert(LinkList *&L,int i,ElemType e);  //插入数据元素  
   21. bool ListDelete(LinkList *&L,int i,ElemType &e);  //删除数据元素  
   22. void Link(LinkList *&L1, LinkList *&L2);
   23. 2、list.cpp的代码：
   24. 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 Link(LinkList *&L1, LinkList *&L2)  
       154. {  
       155.     LinkList *p = L1;  
       156.     while(p->next != NULL)   //找到L1的尾节点  
       157.         p = p->next;  
       158.     p->next = L2->next;  //将L2的首个数据节点连接到L1的尾节点后  
       159.     free(L2);   //释放掉已经无用的L2的头节点  
       160. }
       3、main函数的代码：
   25. 1. #include <stdio.h>  
       2. #include "list.h"  
       3. int main()  
       4. {  
       5.     LinkList *A, *B;  
       6.     int i;  
       7.     ElemType a[]= {1,3,2,9};  
       8.     ElemType b[]= {0,4,7,6,5,8};  
       9.     InitList(A);  
       10.     for(i=3; i>=0; i--)  
       11.         ListInsert(A, 1, a[i]);  
       12.     InitList(B);  
       13.     for(i=5; i>=0; i--)  
       14.         ListInsert(B, 1, b[i]);  
       15.     Link(A, B);  
       16.     printf("A:");  
       17.     DispList(A);  
       18.     DestroyList(A);  
       19.     return 0;  
       20. }
       运行结果：
   26.