单链表的基本操作：建立，求长度，打印，删除，插入，排序，逆置。

没什么好说的=。=

上代码

1. #include <stdio.h>  
2. #include <ctype.h>  
3. #include <string.h>  
4. #include <iostream>  
5. #include <string>  
6. #include <math.h>  
7. #include <vector>  
8. #include <queue>  
9. #include <algorithm>  
10.  
11. using namespace std;  
12.  
13. /************************************************************************/ 
14. /* 单链表的：建立，求长度，打印，删除，插入，排序，逆置                 */ 
15. /************************************************************************/ 
16.  
17. struct node {  
18.         int value ;  
19.         node* next ;  
20.         node() {  
21.             next = NULL ;  
22.         }  
23.         node(int v)  
24.         {  
25.             next = NULL ;  
26.             value = v ;  
27.         }  
28.     };  
29.  
30. class SingleLinkList  
31. {  
32. public:  
33.     SingleLinkList() {  
34.         head = new node();  
35.         tail = NULL ;  
36.     }  
37.       
38.     node* find(int value)  
39.     {  
40.         node* ans = head ;  
41.         while(ans) {  
42.             if( ans->value == value ) break ;  
43.             ans = ans->next ;  
44.         }  
45.         return ans ;  
46.     }  
47.  
48.     void push(int value)  
49.     {  
50.         if(tail) {  
51.             node* temp = new node(value);  
52.             tail->next = temp ;  
53.             tail = temp ;  
54.         }  
55.         else{  
56.             head->value = value ;  
57.             tail = head ;  
58.         }  
59.     }  
60.  
61.     //插入在pos之后，通常先find，在插入  
62.     void insert(node* pos,int value)  
63.     {  
64.         node *temp = new node(value) ;  
65.         if( NULL == pos )  
66.         {  
67.             //插入链表首  
68.             temp->next = head ;  
69.             head = temp ;  
70.         }  
71.         else 
72.         {  
73.             temp->next = pos->next ;  
74.             pos->next = temp ;  
75.         }  
76.     }  
77.  
78.     void del(node* pos)  
79.     {  
80.         node *temp = head , *pre = NULL ;  
81.         while( temp != NULL && temp != pos ) {  
82.             pre = temp ;  
83.             temp = temp->next ;  
84.         }  
85.         if( pre == NULL )  
86.         {  
87.             //删除队首元素  
88.             node* temp = head ;  
89.             head = head->next ;  
90.             delete temp ;  
91.         }  
92.         else 
93.         {  
94.             pre->next = temp->next ;  
95.             delete temp ;  
96.         }  
97.     }  
98.  
99.     //冒泡排序  
100.     void sort()  
101.     {  
102.         int i , j , k ;  
103.         node *pre , *cur ;  
104.         for ( i = 0 ; i < length() ; i++)  
105.         {  
106.             pre = head ;  
107.             cur = head->next ;  
108.             for( j = i+1 ; j < length() ; j++)  
109.             {  
110.                 if( pre->value > cur->value )  
111.                 {  
112.                     k = pre->value ;  
113.                     pre->value = cur->value ;  
114.                     cur->value = k ;  
115.                 }  
116.                 pre = pre->next ;  
117.                 cur = cur->next ;  
118.             }  
119.         }  
120.     }  
121.  
122.     void reverse()  
123.     {  
124.         node *h = head , *t = tail , *temp = head->next , *tmp , *pre = head ;  
125.         while(temp)  
126.         {  
127.             tmp = temp->next ;  
128.             temp->next = pre ;  
129.             pre = temp ;  
130.             temp = tmp ;  
131.         }  
132.         head->next = NULL ;  
133.         tmp = head ;  
134.         head = tail ;  
135.         tail = head ;  
136.     }  
137.  
138.     void print()  
139.     {  
140.         node *temp = head ;  
141.         while(temp) printf("%d ",temp->value) , temp = temp->next ;  
142.         puts("");  
143.     }  
144.  
145.     int length()  
146.     {  
147.         int i = 0 ;  
148.         node *temp = head ;  
149.         while(temp) i++,temp = temp->next ;  
150.         return i ;  
151.     }  
152.  
153. private:  
154.     node *head,*tail;  
155.  
156. };  
157.  
158.  
159. int main()  
160. {  
161.     SingleLinkList list ;  
162.     list.push(3);  
163.     list.push(2);  
164.     list.push(9);  
165.     list.push(1);  
166.     list.push(4);  
167.     puts("initial serial:");  
168.     list.print();  
169.     puts("after reverse:");  
170.     list.reverse();  
171.     list.print();  
172.     printf("length:%d\n",list.length());  
173.     puts("after sorting:");  
174.     list.sort();  
175.     list.print();  
176.       
177.     list.del(list.find(1));  
178.     puts("after delete 1:");  
179.     list.print();  
180.  
181.     list.del(list.find(3));  
182.     puts("after delete 3:");  
183.     list.print();  
184.  
185.     list.del(list.find(9));  
186.     puts("after delete 9:");  
187.     list.print();  
188.  
189.     list.insert(list.find(4),44);  
190.     puts("after insert 44 after 4:");  
191.     list.print();  
192.  
193.     list.insert(list.find(1),0);  
194.     puts("after insert 0 at the first:");  
195.     list.print();  
196. }