第四周-项目二 建立单链表算法库

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

学习了如何建立链表，以及其中算法。