数据结构第二章--线性表链表

转自：http://blog.csdn.net/ggxxkkll/article/details/8661032

线性表的链接存储结构---单链表

图解：

 

 

 

 

 

LinkList.h文件

 

[cpp] view plaincopy

1. //LinkList.h  声明类LinkList  
2. #ifndef LinkList_H  
3. #define LinkList_H  
4. template <class T>  
5. struct Node  
6. {  
7.   T data;  
8.   Node<T> *next;  //此处<T>也可以省略  
9. };  
10.   
11. template <class T>  
12. class LinkList  
13. {  
14.   public:  
15.     LinkList( );  //建立只有头结点的空链表  
16.     LinkList(T a[ ], int n);  //建立有n个元素的单链表  
17.     ~LinkList();             //析构函数  
18.     int Length();          //求单链表的长度  
19.     T Get(int i);           //取单链表中第i个结点的元素值  
20.     int Locate(T x);       //求单链表中值为x的元素序号  
21.     void Insert(int i, T x);   //在单链表中第i个位置插入元素值为x的结点  
22.     T Delete(int i);        //在单链表中删除第i个结点  
23.     void PrintList( );           //遍历单链表，按序号依次输出各元素  
24.  private:  
25.    Node<T> *first;  //单链表的头指针  
26. };  
27.   
28. #endif  

 

LinkList.cpp文件

[cpp] view plaincopy

1. //LinkList.cpp  
2. #include "LinkList.h"  
3. /* 
4. *前置条件：单链表不存在 
5. *输    入：无 
6. *功    能：构建一个单链表 
7. *输    出：无 
8. *后置条件：构建一个单链表 
9. */  
10. template <class T>  
11. LinkList<T>:: LinkList( )  
12. {  
13.  first=new Node<T>; first->next=NULL;  
14. }  
15. /* 
16. *前置条件：单链表不存在 
17. *输    入：顺序表信息的数组形式a[],单链表长度n 
18. *功    能：将数组a[]中元素建为长度为n的单链表 
19. *输    出：无 
20. *后置条件：构建一个单链表 
21. */  
22.    
23. template <class T>    
24. LinkList<T>:: LinkList(T a[ ], int n)  
25.  {  
26.     first=new Node<T>;   //生成头结点  
27.     Node<T> *r,*s;  
28.      r=first;          //尾指针初始化  
29.     for (int i=0; i<n; i++)  
30.     {   
31.       s=new Node<T>; s->data=a[i];  //为每个数组元素建立一个结点  
32.       r->next=s; r=s;      //插入到终端结点之后  
33.     }  
34.     r->next=NULL;    //单链表建立完毕，将终端结点的指针域置空  
35.  }  
36.   
37.   
38. /* 
39. *前置条件：无 
40. *输    入：无 
41. *功    能：无 
42. *输    出：无 
43. *后置条件：无 
44. */  
45. template <class T>  
46. LinkList<T>:: ~LinkList()  
47. {  
48. }  
49. /* 
50. *前置条件：单链表存在 
51. *输    入：查询元素位置i 
52. *功    能：按位查找位置为i的元素并输出值 
53. *输    出：查询元素的值 
54. *后置条件：单链表不变 
55. */  
56. template <class T>  
57. T LinkList<T>::Get(int i)   
58. {     
59.   Node<T> *p; int j;  
60.   p=first->next;  j=1;  //或p=first;  j=0;  
61.   while (p && j<i)      
62.   {  
63.     p=p->next;       //工作指针p后移  
64.     j++;  
65.   }  
66.   if (!p) throw "位置";  
67.   else return p->data;  
68. }  
69.   
70. /* 
71. *前置条件：单链表存在 
72. *输    入：查询元素值x 
73. *功    能：按值查找值的元素并输出位置 
74. *输    出：查询元素的位置 
75. *后置条件：单链表不变 
76. */  
77. template <class T>   
78. int LinkList<T>::Locate(T x)  
79. {  
80.     Node<T> *p; int j;  
81.     p=first->next; j=1;  
82.     if(p&&p->next){  
83.       while(p->data!=x)  
84.       {  
85.          p=p->next;  
86.          j++;  
87.       }  
88.     return j;  
89.     }  
90.     else throw "位置";  
91.       
92. }  
93.   
94. /* 
95. *前置条件：单链表存在 
96. *输    入：插入元素x,插入位置i 
97. *功    能：将元素x插入到单链表中位置i处 
98. *输    出：无 
99. *后置条件：单链表插入新元素 
100. */  
101. template <class T>    
102. void LinkList<T>::Insert(int i, T x)  
103. {    
104.    Node<T> *p; int j;  
105.    p=first ; j=0;    //工作指针p初始化  
106.    while (p && j<i-1)  
107.    {  
108.      p=p->next;   //工作指针p后移  
109.      j++;  
110.    }  
111.    if (!p) throw "位置";  
112.     else {   
113.       Node<T> *s;  
114.       s=new Node<T>;   
115.       s->data=x;  //向内存申请一个结点s，其数据域为x  
116.       s->next=p->next;       //将结点s插入到结点p之后  
117.       p->next=s;  
118.     }  
119. }  
120.   
121. /* 
122. *前置条件：单链表存在 
123. *输    入：无 
124. *功    能：输出单链表长度 
125. *输    出：单链表长度 
126. *后置条件：单链表不变 
127. */  
128. template <class T>   
129. int LinkList<T>::Length( )  
130. {  
131.   Node <T> *p = first->next;  
132.   int i = 0;  
133.   while(p)  
134.   {  
135.     p = p->next;  
136.     i++;  
137.   }  
138.   return i;  
139. }  
140. /* 
141. *前置条件：单链表存在 
142. *输    入：要删除元素位置i 
143. *功    能：删除单链表中位置为i的元素 
144. *输    出：无 
145. *后置条件：单链表删除元素 
146. */  
147. template <class T>    
148. T LinkList<T>::Delete(int i)  
149. {   
150.   Node<T> *p; int j;  
151.   p=first ; j=0;  //工作指针p初始化  
152.   while (p && j<i-1)  //查找第i-1个结点  
153.   {  
154.     p=p->next;  
155.     j++;  
156.   }  
157.   if (!p || !p->next) throw "位置";  //结点p不存在或结点p的后继结点不存在  
158.     else {  
159.           Node<T> *q; int x;  
160.           q=p->next; x=q->data;  //暂存被删结点  
161.           p->next=q->next;  //摘链  
162.           delete q;   
163.           return x;  
164.     }  
165. }  
166. /* 
167. *前置条件：单链表存在 
168. *输    入：无 
169. *功    能：单链表遍历 
170. *输    出：输出所有元素 
171. *后置条件：单链表不变 
172. */  
173. template <class T>   
174. void LinkList<T>::PrintList( )  
175. {  
176.     Node<T> *p;  
177.     p=first->next;  
178.     while (p)  
179.     {  
180.       cout<<p->data<<endl;  
181.       p=p->next;  
182.     }  
183.       
184. }  

"Common.h"

[cpp] view plaincopy

1. #ifndef COMMON_H_INCLUDED  
2. #define COMMON_H_INCLUDED  
3.   
4. #include <stdio.h>  
5. #include <stdlib.h>  
6. #include <string.h>  
7. #include <stdarg.h>  
8.   
9. #define TRUE 1  
10. #define FALSE 0  
11. #define OK 1  
12. #define ERROR 0  
13. #define INFEASIBLE -1  
14. #define OVERFLOW -2  
15.   
16. typedef int Status;  
17. typedef int ElemType;  
18.   
19. #endif // COMMON_H_INCLUDED  

"List_Linked.h"

[cpp] view plaincopy

1. #ifndef LIST_LINKED_H_INCLUDED  
2. #define LIST_LINKED_H_INCLUDED  
3.   
4. #include "Common.h"  
5.   
6. typedef struct LNode {//结点类型  
7.     ElemType data;  
8.     struct LNode * next;  
9. } Link, * Position;  
10.   
11. typedef struct {//链表类型  
12.     Link * head;  
13.     Link * tail;  
14.     int len;  
15. } LinkList;  
16.   
17. Status MakeNode_Linked(Link * p, ElemType e);  
18. void FreeNode_Linked(Link * p);  
19.   
20. Status InitList_Linked(LinkList * l);  
21. Status DestroyList_Linked(LinkList * l);  
22. Status ClearList_Linked(LinkList * l);  
23. Status InsFirst_Linked(LinkList * l, Link * s);//h为头结点，s为所指结点，s插入到第一个结点前  
24. Status DelFirst_Linked(LinkList * l, Link * q);  
25. Status Append_Linked(LinkList * l, Link * s);//将s所指一串结点链接在list的最后一个结点并修改list尾指针  
26. Status Remove_Linked(LinkList * l, Link * q);//删除尾结点，以q返回，改变list尾指针  
27. Status InsBefore_Linked(LinkList * l, Link * p, Link * s);//在p指向的结点前插入结点s，修改指针p指向新插入的结点  
28. Status InsAfter_Linked(LinkList * l, Link * p, Link * s);  
29. Status SetCurElem_Linked(Link * p, ElemType e);//用e更新p的值  
30. ElemType GetCurElem_Linked(Link p);  
31. Status ListEmpty_Linked(LinkList * l);  
32. int ListLength_Linked(LinkList * l);  
33. Position GetHead_Linked(LinkList * l);  
34. Position GetLast_Linked(LinkList * l);  
35. Position PriorPos_Linked(LinkList * l, Link * p);//返回p的前驱  
36. Position NextPos_Linked(LinkList * l, Link * p);  
37. Status LocatePos_Linked(LinkList * l, int i, Link * p);//p返回list中第i个结点的位置  
38. Position LocateElem_Linked(LinkList * l, ElemType e);//返回list中与e相等的元素的位置  
39. Status ListTraverse_Linked(LinkList * l);  
40.   
41. #endif // LIST_LINKED_H_INCLUDED  

"List_Linked.c"

[cpp] view plaincopy

1. #include "List_Linked.h"  
2.   
3. Status MakeNode_Linked(Link * p, ElemType e)  
4. {  
5.     p->data = e;  
6.     p->next = NULL;  
7.     return OK;  
8. }  
9. void FreeNode_Linked(Link * p)  
10. {  
11.     free(p);  
12. }  
13.   
14. Status InitList_Linked(LinkList * l)  
15. {  
16.     l->head = (Link *)malloc(sizeof(Link));  
17.     l->tail = (Link *)malloc(sizeof(Link));  
18.     if(!l->head || !l->tail)  
19.         exit(OVERFLOW);  
20.     l->len = 0;  
21.     l->head = l->tail;  
22.     l->tail->next = NULL;  
23.     return OK;  
24. }  
25. Status DestroyList_Linked(LinkList * l)  
26. {  
27.     ClearList_Linked(l);  
28.     free(l->head);  
29.     l->tail = NULL;  
30.     l->len = 0;  
31.     l = NULL;  
32.     return OK;  
33. }  
34. Status ClearList_Linked(LinkList * l)  
35. {  
36.     Link * temp;  
37.     Link * temp2;  
38.     if(l->head != l->tail)  
39.     {  
40.         temp = l->head->next;  
41.         l->head->next = NULL;  
42.         l->len = 0;  
43.         while(temp != l->tail)  
44.         {  
45.             temp2 = temp->next;  
46.             free(temp);  
47.             temp = temp2;  
48.         }  
49.         free(temp);  
50.         l->tail = l->head;  
51.     }  
52.     return OK;  
53. }  
54.   
55. Status InsFirst_Linked(LinkList * l, Link * s)//h为头结点，s为所指结点，s插入到第一个结点前  
56. {  
57.     Link * h = l->head;  
58.     if(h != l->tail)  
59.     {  
60.         s->next = h->next;  
61.     }  
62.     else  
63.     {  
64.         s->next = NULL;  
65.         l->tail = s;  
66.     }  
67.     h->next = s;  
68.     l->len++;  
69.     return OK;  
70. }  
71.   
72. Status DelFirst_Linked(LinkList * l, Link * q)  
73. {  
74.     if(l->head != l->tail)  
75.     {  
76.         q = l->head->next;  
77.         if(!q->next)  
78.         {  
79.             l->tail = l->head;  
80.         }  
81.         else  
82.         {  
83.             l->head->next = q->next;  
84.         }  
85.   
86.         l->len--;  
87.         return OK;  
88.     }  
89.     else  
90.     {  
91.         return ERROR;  
92.     }  
93. }  
94. Status Append_Linked(LinkList * l, Link * s)//将s所指一串结点链接在list的最后一个结点并修改list尾指针  
95. {  
96.     Link * temp = l->tail;  
97.     temp->next = s;  
98.     int i = 1;  
99.     while(temp->next)  
100.     {  
101.         temp = temp->next;  
102.         i++;  
103.     }  
104.     l->len += i;  
105.     l->tail = temp;  
106.     return OK;  
107. }  
108. Status Remove_Linked(LinkList * l, Link * q)//删除尾结点，以q返回，改变list尾指针  
109. {  
110.     Link * temp = l->head;  
111.     while(temp->next->next)  
112.     {  
113.         temp = temp->next;  
114.     }  
115.     *q = *temp->next;  
116.     l->tail = temp;  
117.     l->tail->next = NULL;  
118.     printf("%d  ", q->data);  
119.     return OK;  
120. }  
121. Status InsBefore_Linked(LinkList * l, Link * p, Link * s)//在p指向的结点前插入结点s，修改指针p指向新插入的结点  
122. {  
123.     Link * temp = l->head;  
124.     while(temp->next && temp->next != p)  
125.     {  
126.         temp = temp->next;  
127.     }  
128.     s->next = p;  
129.     temp->next = s;  
130.     l->len++;  
131.     return OK;  
132. }  
133. Status InsAfter_Linked(LinkList * l, Link * p, Link * s)  
134. {  
135.     s->next = p->next;  
136.     p->next = s;  
137.     if(p == l->tail)  
138.     {  
139.         l->tail = s;  
140.     }  
141.     l->len++;  
142.     return OK;  
143. }  
144. Status SetCurElem_Linked(Link * p, ElemType e)//用e更新p的值  
145. {  
146.     p->data = e;  
147.     return OK;  
148. }  
149. ElemType GetCurElem_Linked(Link p)  
150. {  
151.     return p.data;  
152. }  
153. Status ListEmpty_Linked(LinkList * l)  
154. {  
155.     if(l->head == l->tail)  
156.         return TRUE;  
157.     else  
158.         return FALSE;  
159. }  
160. int ListLength_Linked(LinkList * l)  
161. {  
162.     return l->len;  
163. }  
164. Position GetHead_Linked(LinkList * l)  
165. {  
166.     return l->head;  
167. }  
168. Position GetLast_Linked(LinkList * l)  
169. {  
170.     return l->tail;  
171. }  
172. Position PriorPos_Linked(LinkList * l, Link * p)//返回p的前驱  
173. {  
174.     Link * temp = l->head;  
175.     while(temp && temp->next!=p)  
176.         temp = temp->next;  
177.     return temp;  
178. }  
179. Position NextPos_Linked(LinkList * l, Link * p)  
180. {  
181.     return p->next;  
182. }  
183. Status LocatePos_Linked(LinkList * l, int i, Link * p)//p返回list中第i个结点的位置  
184. {  
185.     if(i<1 || i>ListLength_Linked(l))  
186.     {  
187.         return ERROR;  
188.     }  
189.     int j;  
190.     Link * temp = l->head;  
191.     for(j=0; j<i; j++)  
192.     {  
193.         temp = temp->next;  
194.     }  
195.     *p = *temp;  
196.     return OK;  
197. }  
198. Position LocateElem_Linked(LinkList * l, ElemType e)//返回list中与e相等的元素的位置  
199. {  
200.     Link * temp = l->head;  
201.     while(temp)  
202.     {  
203.         if(temp->data == e)  
204.             return temp;  
205.         temp = temp->next;  
206.     }  
207.     return NULL;  
208. }  
209. Status ListTraverse_Linked(LinkList * l)  
210. {  
211.     if(l->len != 0)  
212.     {  
213.         Link * temp = l->head->next;  
214.         while(temp)  
215.         {  
216.             printf("%d  ", temp->data);  
217.             temp = temp->next;  
218.         }  
219.     }  
220.     return OK;  
221.   
222. }