类模板 实现链表

模板类的声明和实现要放在同一个文件夹下才行，不然会提示找不到函数

[cpp]  view plain copy

1. #ifndef LinkList_HH  
2. #define LinkList_HH  
3. #include<stdlib.h>  
4. #include <stdio.h>  
5. template <typename type>  
6.   
7.   
8. struct Node  
9. {  
10.     type value;  
11.     Node *next;  
12. };  
13.   
14.   
15. template <typename type>  
16. class LinkList  
17. {  
18. private:  
19.     int Length;  
20.     Node<type> *head;  
21. public:  
22.     LinkList();  
23.     bool add(type);//添加节点  
24.     bool remove(int);//删除节点  
25.     type getValue(int);//获得某节点的值  
26.     int getIndex(type);//获取某节点的索引  
27.     int getLength();//获取链表的长度  
28.     Node<type>* getHead();//获取链表的头指针  
29.     bool addnode(int ,type);//增加节点信息 插入到第int个之后  
30.     ~LinkList();//释放链表  
31. };  
32.   
33.   
34. template <typename type>  
35. LinkList<type>::LinkList()  
36. {  
37.     head = (new Node<type>());  
38.     Length = -1;  
39.     head->next = NULL;  
40. }  
41.   
42.   
43. template <typename type>  
44. bool LinkList<type>::add(type value)  
45. {  
46.     try{  
47.         if(Length == -1)  
48.         {  
49.             head->value = value;  
50.             head->next = NULL;  
51.             Length = 0;  
52.             return true;  
53.         }  
54.   
55. Node<type> *temp = head;  
56. while(temp->next != NULL)  
57. {  
58. temp = temp->next;  
59. }  
60. Node<type> *node = new Node<type>();  
61. node->value = value;  
62. node->next = NULL;  
63. temp->next = node;  
64. ++Length;  
65. return true;  
66.     }catch(...){}  
67.     return false;  
68. }  
69. template <typename type>  
70. bool LinkList<type>::remove(int index)  
71. {  
72.     if(index > Length || index < 0)  
73.     {  
74.         return false;  
75.     }  
76.   
77.     Node<type> *aTemp = head;  
78.     Node<type> *pTemp = NULL;  
79.     int count = 0;  
80.     while(count <= Length)  
81.     {  
82.         if(count == index && index == 0)  
83.         {  
84.             head =aTemp->next;  
85.             free(aTemp);  
86.             aTemp = NULL;  
87.             Length--;  
88.             break;  
89.         }  
90.         if(count == index)  
91.         {  
92.             pTemp->next = aTemp->next;  
93.             free(aTemp);  
94.             Length--;  
95.             aTemp = NULL;  
96.             break;  
97.         }  
98.         pTemp = aTemp;  
99.         aTemp = aTemp->next;  
100.         count++;  
101.     }  
102.     return true;  
103. }  
104. template <typename type>  
105.   
106.   
107. bool LinkList<type>::addnode(int index, type value)  
108. {  
109. try{  
110.         if(index ==Length)  
111.         {  
112. add(value);  
113. return true;  
114.         }  
115. else if(index<0||index>Length)  
116. {  
117. printf("不可预料的站点位置\n");  
118. return false;  
119. }  
120. int count =0;  
121. Node<type> *temp = head;  
122. while(count<index)  
123. {  
124. temp = temp->next;  
125. count++;  
126. }  
127. Node<type> *node = new Node<type>();  
128. node->value = value;  
129. node->next = temp->next;  
130. temp->next = node;  
131. ++Length;  
132. return true;  
133.     }catch(...){}  
134.     return false;  
135. }  
136. template <typename type>  
137. int LinkList<type>::getLength()  
138. {  
139.     return Length+1;  
140. }  
141. template <typename type>  
142.   
143.   
144. Node<type>* LinkList<type>::getHead()  
145. {  
146.     return head;  
147. }  
148. template <typename type>  
149. type LinkList<type>::getValue(int index)  
150. {  
151.     if(index < 0 || index > Length)  
152.     {  
153.         return NULL;  
154.     }  
155.     Node<type> * temp = head;  
156.     int count = 0;  
157.     while(count <= Length)  
158.     {  
159.         if(count == index)  
160.         {  
161.             return temp->value;  
162.         }  
163.         temp = temp->next;  
164.         count++;  
165.     }  
166.     return NULL;  
167. }  
168. template <typename type>  
169. int LinkList<type>::getIndex(type value)  
170. {  
171.     if(Length == -1)  
172.     {  
173.         return -1;  
174.     }  
175.     Node<type> *temp = head;  
176.     int count = 0;  
177.     while(count <= Length)  
178.     {  
179.         type v = temp->value;  
180.         if(v == value)  
181.         {  
182.             return count;  
183.         }  
184.         temp = temp->next;  
185.         count++;  
186.     }  
187.     return -1;  
188. }  
189. template <typename type>  
190. LinkList<type>::~LinkList()  
191. {  
192. Node<type> *temp = head;  
193. Node<type> *temp1 = NULL;  
194. int count = 0;  
195. while(count <= Length)  
196. {  
197. temp1 = temp;  
198. if(temp1 != NULL)  
199. {  
200. temp = temp->next;  
201. free(temp1);  
202. temp1 = NULL;  
203. }  
204. count++;  
205. }  
206. }  
207. #endif