数据结构项目第四周(三）——单链表的应用

1. Copyright (c) 2017,烟台大学计算机与控制工程学院             
2.         
3. 2.*All rights reserved.             
4. 1.*文件名称：             
5. 2.*作    者：李庆耀            
6. 3.*完成日期：2017年11月9日             
7. 4.*版 本 号：v1.0             
8. 5.*问题描述：　完成下面的应用时，除项目中给出的特殊要求，其余工作均可利用项目2完成的算法支持。  
9.   

代码：

1. main.cpp  
2.   
3. #include "linklist.h"  
4. #include <iostream>  
5. using namespace std;  
6. int main()  
7. {  
8.     LinkList *L;  
9.     InitList(L);  
10.     ListInsert(L, 1, 15);  
11.     ListInsert(L, 1, 10);  
12.     ListInsert(L, 1, 5);  
13.     ListInsert(L, 1, 20);  
14.     cout<<"逆置前:";  
15.     DispList(L);  
16.     Reverse(L);  
17.     cout<<"逆置后:";  
18.   
19.     DispList(L);  
20.     DestroyList(L);  
21.     return 0;  
22. }  
23.   
24. linklist.cpp  
25.   
26. #include <stdio.h>  
27. #include <malloc.h>  
28. #include "linklist.h"  
29.   
30.   
31. void CreateListF(LinkList *&L,ElemType a[],int n)//头插法建立单链表  
32. {  
33.     LinkList *s;  
34.     int i;  
35.     L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点  
36.     L->next=NULL;  
37.     for (i=0; i<n; i++)  
38.     {  
39.         s=(LinkList *)malloc(sizeof(LinkList));//创建新结点  
40.         s->data=a[i];  
41.         s->next=L->next;            //将*s插在原开始结点之前,头结点之后  
42.         L->next=s;  
43.     }  
44. }  
45.   
46. void CreateListR(LinkList *&L,ElemType a[],int n)//尾插法建立单链表  
47. {  
48.     LinkList *s,*r;  
49.     int i;  
50.     L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点  
51.     L->next=NULL;  
52.     r=L;                    //r始终指向终端结点,开始时指向头结点  
53.     for (i=0; i<n; i++)  
54.     {  
55.         s=(LinkList *)malloc(sizeof(LinkList));//创建新结点  
56.         s->data=a[i];  
57.         r->next=s;          //将*s插入*r之后  
58.         r=s;  
59.     }  
60.     r->next=NULL;           //终端结点next域置为NULL  
61. }  
62.   
63. void InitList(LinkList *&L)  
64. {  
65.     L=(LinkList *)malloc(sizeof(LinkList));     //创建头结点  
66.     L->next=NULL;  
67. }  
68. void DestroyList(LinkList *&L)  
69. {  
70.     LinkList *p=L,*q=p->next;  
71.     while (q!=NULL)  
72.     {  
73.         free(p);  
74.         p=q;  
75.         q=p->next;  
76.     }  
77.     free(p);    //此时q为NULL,p指向尾结点,释放它  
78. }  
79. bool ListEmpty(LinkList *L)  
80. {  
81.     return(L->next==NULL);  
82. }  
83. int ListLength(LinkList *L)  
84. {  
85.     LinkList *p=L;  
86.     int i=0;  
87.     while (p->next!=NULL)  
88.     {  
89.         i++;  
90.         p=p->next;  
91.     }  
92.     return(i);  
93. }  
94. void DispList(LinkList *L)  
95. {  
96.     LinkList *p=L->next;  
97.     while (p!=NULL)  
98.     {  
99.         printf("%d ",p->data);  
100.         p=p->next;  
101.     }  
102.     printf("\n");  
103. }  
104. bool GetElem(LinkList *L,int i,ElemType &e)  
105. {  
106.     int j=0;  
107.     LinkList *p=L;  
108.     while (j<i && p!=NULL)  
109.     {  
110.         j++;  
111.         p=p->next;  
112.     }  
113.     if (p==NULL)            //不存在第i个数据结点  
114.         return false;  
115.     else                    //存在第i个数据结点  
116.     {  
117.         e=p->data;  
118.         return true;  
119.     }  
120. }  
121. int LocateElem(LinkList *L,ElemType e)  
122. {  
123.     LinkList *p=L->next;  
124.     int n=1;  
125.     while (p!=NULL && p->data!=e)  
126.     {  
127.         p=p->next;  
128.         n++;  
129.     }  
130.     if (p==NULL)  
131.         return(0);  
132.     else  
133.         return(n);  
134. }  
135. bool ListInsert(LinkList *&L,int i,ElemType e)  
136. {  
137.     int j=0;  
138.     LinkList *p=L,*s;  
139.     while (j<i-1 && p!=NULL) //查找第i-1个结点  
140.     {  
141.         j++;  
142.         p=p->next;  
143.     }  
144.     if (p==NULL)    //未找到位序为i-1的结点  
145.         return false;  
146.     else            //找到位序为i-1的结点*p  
147.     {  
148.         s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s  
149.         s->data=e;  
150.         s->next=p->next;                        //将*s插入到*p之后  
151.         p->next=s;  
152.         return true;  
153.     }  
154. }  
155. bool ListDelete(LinkList *&L,int i,ElemType &e)  
156. {  
157.     int j=0;  
158.     LinkList *p=L,*q;  
159.     while (j<i-1 && p!=NULL)    //查找第i-1个结点  
160.     {  
161.         j++;  
162.         p=p->next;  
163.     }  
164.     if (p==NULL)                //未找到位序为i-1的结点  
165.         return false;  
166.     else                        //找到位序为i-1的结点*p  
167.     {  
168.         q=p->next;              //q指向要删除的结点  
169.         if (q==NULL)  
170.             return false;           //若不存在第i个结点,返回false  
171.         e=q->data;  
172.         p->next=q->next;        //从单链表中删除*q结点  
173.         free(q);                //释放*q结点  
174.         return true;  
175.     }  
176. }  
177. void Reverse(LinkList *&L)  
178. {  
179.     LinkList *p=L->next,*q;  
180.     L->next=NULL;  
181.     while (p!=NULL)     //扫描所有的结点  
182.     {  
183.         q=p->next;      //让q指向*p结点的下一个结点  
184.         p->next=L->next;    //总是将*p结点作为第一个数据结点  
185.         L->next=p;  
186.         p=q;            //让p指向下一个结点  
187.     }  
188. }  
189.   
190. linklist.h  
191.   
192. #ifndef LINKLIST_H_INCLUDED  
193. #define LINKLIST_H_INCLUDED  
194. typedef int ElemType;  
195. typedef struct LNode        //定义单链表结点类型  
196. {  
197.     ElemType data;  
198.     struct LNode *next;     //指向后继结点  
199. }LinkList;  
200. void CreateListF(LinkList *&L,ElemType a[],int n);//头插法建立单链表  
201. void CreateListR(LinkList *&L,ElemType a[],int n);//尾插法建立单链表  
202. void InitList(LinkList *&L);  //初始化线性表  
203. void DestroyList(LinkList *&L);  //销毁线性表  
204. bool ListEmpty(LinkList *L);  //判断线性表是否为空  
205. int ListLength(LinkList *L);  //求线性表长度  
206. void DispList(LinkList *L);  //输出线性表  
207. bool GetElem(LinkList *L,int i,ElemType &e);  //求线性表某个数据元素值  
208. int LocateElem(LinkList *L,ElemType e);  //按元素值查找  
209. bool ListInsert(LinkList *&L,int i,ElemType e);  //插入数据元素  
210. bool ListDelete(LinkList *&L,int i,ElemType &e);  //删除数据元素  
211. void Reverse(LinkList *&L);  
212. #endif // LINKLIST_H_INCLUDED  

运行结果：