第四周项目3——单链表应用（2）

来源：互联网发布：goodbye my lover 知乎编辑：程序博客网时间：2024/06/14 06:41

/*
* 文件名称：wu.cpp
* 作者：武昊
* 完成日期：2016年9月22日
* 版本号：v1.0
*问题描述：已知L1和L2分别指向两个单链表的头结点，且已知其长度分别为m、n，
请设计算法将L2连接到L1的后面。实现这个算法，完成测试，并分析这个算法的复杂度。
提示：实现算法时，可以设计下面的函数：void Link(LinkList &L1, LinkList &L2)
*输入描述：无
*程序输出：链表
*/
main.cpp
1. 1. #include "linklist.h"
  3. void Link(LinkList *&L1, LinkList *&L2)
  4. {
  5. LinkList *p = L1;
  6. while(p->next != NULL) //找到L1的尾节点
  7. p = p->next;
  8. p->next = L2->next; //将L2的首个数据节点连接到L1的尾节点后
  9. free(L2); //释放掉已经无用的L2的头节点
  10. }
  12. int main()
  13. {
  14. LinkList *A, *B;
  15. int i;
  16. ElemType a[]= {1,3,2,9};
  17. ElemType b[]= {0,4,7,6,5,8};
  18. InitList(A);
  19. for(i=3; i>=0; i--)
  20. ListInsert(A, 1, a[i]);
  21. InitList(B);
  22. for(i=5; i>=0; i--)
  23. ListInsert(B, 1, b[i]);
  24. Link(A, B);
  25. printf("A:");
  26. DispList(A);
  27. DestroyList(A);
  28. return 0;
  29. }
linklist.cpp
1. #include <stdio.h>
2. #include <malloc.h>
3. #include "linklist.h"
6. void CreateListF(LinkList *&L,ElemType a[],int n)//头插法建立单链表
7. {
8. LinkList *s;
9. int i;
10. L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点
11. L->next=NULL;
12. for (i=0; i<n; i++)
13. {
14. s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
15. s->data=a[i];
16. s->next=L->next; //将*s插在原开始结点之前,头结点之后
17. L->next=s;
18. }
19. }
21. void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法建立单链表
22. {
23. LinkList *s,*r;
24. int i;
25. L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点
26. L->next=NULL;
27. r=L; //r始终指向终端结点,开始时指向头结点
28. for (i=0; i<n; i++)
29. {
30. s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
31. s->data=a[i];
32. r->next=s; //将*s插入*r之后
33. r=s;
34. }
35. r->next=NULL; //终端结点next域置为NULL
36. }
38. void InitList(LinkList *&L)
39. {
40. L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点
41. L->next=NULL;
42. }
43. void DestroyList(LinkList *&L)
44. {
45. LinkList *p=L,*q=p->next;
46. while (q!=NULL)
47. {
48. free(p);
49. p=q;
50. q=p->next;
51. }
52. free(p); //此时q为NULL,p指向尾结点,释放它
53. }
54. bool ListEmpty(LinkList *L)
55. {
56. return(L->next==NULL);
57. }
58. int ListLength(LinkList *L)
59. {
60. LinkList *p=L;
61. int i=0;
62. while (p->next!=NULL)
63. {
64. i++;
65. p=p->next;
66. }
67. return(i);
68. }
69. void DispList(LinkList *L)
70. {
71. LinkList *p=L->next;
72. while (p!=NULL)
73. {
74. printf("%d ",p->data);
75. p=p->next;
76. }
77. printf("\n");
78. }
79. bool GetElem(LinkList *L,int i,ElemType &e)
80. {
81. int j=0;
82. LinkList *p=L;
83. while (j<i && p!=NULL)
84. {
85. j++;
86. p=p->next;
87. }
88. if (p==NULL) //不存在第i个数据结点
89. return false;
90. else //存在第i个数据结点
91. {
92. e=p->data;
93. return true;
94. }
95. }
96. int LocateElem(LinkList *L,ElemType e)
97. {
98. LinkList *p=L->next;
99. int n=1;
100. while (p!=NULL && p->data!=e)
101. {
102. p=p->next;
103. n++;
104. }
105. if (p==NULL)
106. return(0);
107. else
108. return(n);
109. }
110. bool ListInsert(LinkList *&L,int i,ElemType e)
111. {
112. int j=0;
113. LinkList *p=L,*s;
114. while (j<i-1 && p!=NULL) //查找第i-1个结点
115. {
116. j++;
117. p=p->next;
118. }
119. if (p==NULL) //未找到位序为i-1的结点
120. return false;
121. else //找到位序为i-1的结点*p
122. {
123. s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
124. s->data=e;
125. s->next=p->next; //将*s插入到*p之后
126. p->next=s;
127. return true;
128. }
129. }
130. bool ListDelete(LinkList *&L,int i,ElemType &e)
131. {
132. int j=0;
133. LinkList *p=L,*q;
134. while (j<i-1 && p!=NULL) //查找第i-1个结点
135. {
136. j++;
137. p=p->next;
138. }
139. if (p==NULL) //未找到位序为i-1的结点
140. return false;
141. else //找到位序为i-1的结点*p
142. {
143. q=p->next; //q指向要删除的结点
144. if (q==NULL)
145. return false; //若不存在第i个结点,返回false
146. e=q->data;
147. p->next=q->next; //从单链表中删除*q结点
148. free(q); //释放*q结点
149. return true;
150. }
151. }
linklist.h
1. #ifndef LINKLIST_H_INCLUDED
2. #define LINKLIST_H_INCLUDED
4. typedef int ElemType;
5. typedef struct LNode //定义单链表结点类型
6. {
7. ElemType data;
8. struct LNode *next; //指向后继结点
9. }LinkList;
10. void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表
11. void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表
12. void InitList(LinkList *&L); //初始化线性表
13. void DestroyList(LinkList *&L); //销毁线性表
14. bool ListEmpty(LinkList *L); //判断线性表是否为空
15. int ListLength(LinkList *L); //求线性表长度
16. void DispList(LinkList *L); //输出线性表
17. bool GetElem(LinkList *L,int i,ElemType &e); //求线性表某个数据元素值
18. int LocateElem(LinkList *L,ElemType e); //按元素值查找
19. bool ListInsert(LinkList *&L,int i,ElemType e); //插入数据元素
20. bool ListDelete(LinkList *&L,int i,ElemType &e); //删除数据元素
22. #endif // LINKLIST_H_INCLUDED
运行结果：
总结：
程序的实现采用多组织结构，利用了单链表算法库，关键是将l1的尾节点和l2的首个数据节点连起来即可。

0 0